com/hypixel/hytale/event/AsyncEventBusRegistry.java
package com.hypixel.hytale.event;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.sneakythrow.SneakyThrow;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class AsyncEventBusRegistry<KeyType, EventType extends IAsyncEvent<KeyType>> extends EventBusRegistry<KeyType, EventType, AsyncEventConsumerMap<EventType>> {
@Nonnull
public static final IEventDispatcher NO_OP = new IEventDispatcher<IAsyncEvent, CompletableFuture<IAsyncEvent>>() {
public boolean hasListener() {
return false;
}
@Nonnull
public CompletableFuture<IAsyncEvent> dispatch(IAsyncEvent event) {
return CompletableFuture.completedFuture(event);
}
};
@Nonnull
private final IEventDispatcher<EventType, CompletableFuture<EventType>> globalDispatcher = (event) -> {
CompletableFuture<EventType> future = CompletableFuture.completedFuture(event);
CompletableFuture<EventType> before = future;
future = this.dispatchGlobal(future);
if (before == future) {
future = this.dispatchUnhandled(future);
}
return future;
};
public AsyncEventBusRegistry(@Nonnull HytaleLogger logger, @Nonnull Class<EventType> eventClass) {
super(logger, eventClass, new AsyncEventConsumerMap((AsyncEventBusRegistry)null), new AsyncEventConsumerMap((AsyncEventBusRegistry)null));
(this.global).registry = (this.unhandled).registry = this;
}
@Nonnull
public EventRegistration<KeyType, EventType> registerAsync(short priority, @Nonnull KeyType key, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
return this.registerAsync0(priority, key, function, function.toString());
}
@Nonnull
private EventRegistration<KeyType, EventType> registerAsync0(short priority, @Nullable KeyType key, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function, @Nonnull String consumerString) {
if (this.shutdown) {
throw new IllegalArgumentException("EventRegistry is shutdown!");
} else {
KeyType k = (KeyType)(key != null ? key : NULL);
AsyncEventConsumerMap<EventType> eventMap = (AsyncEventConsumerMap)this.map.computeIfAbsent(k, (o) -> new AsyncEventConsumerMap(this));
AsyncEventConsumer<EventType> eventConsumer = new AsyncEventConsumer<EventType>(priority, consumerString, function);
eventMap.add(eventConsumer);
return new EventRegistration<KeyType, EventType>(this.eventClass, this::isAlive, () -> this.unregister(key, eventConsumer));
}
}
private void unregister(@Nullable KeyType key, @Nonnull AsyncEventConsumer<EventType> consumer) {
if (this.shutdown) {
throw new IllegalArgumentException("EventRegistry is shutdown!");
} else {
KeyType k = (KeyType)(key != null ? key : NULL);
AsyncEventConsumerMap<EventType> eventMap = (AsyncEventConsumerMap)this.map.get(k);
if (eventMap != null && !eventMap.remove(consumer)) {
throw new IllegalArgumentException(String.valueOf(consumer));
}
}
}
@Nonnull
public EventRegistration<KeyType, EventType> registerAsyncGlobal(short priority, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
return this.registerAsyncGlobal0(priority, function, function.toString());
}
@Nonnull
private EventRegistration<KeyType, EventType> registerAsyncGlobal0(short priority, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function, @Nonnull String consumerString) {
if (this.shutdown) {
throw new IllegalArgumentException("EventRegistry is shutdown!");
} else {
AsyncEventConsumer<EventType> eventConsumer = new AsyncEventConsumer<EventType>(priority, consumerString, function);
((AsyncEventConsumerMap)this.global).add(eventConsumer);
return new EventRegistration<KeyType, EventType>(this.eventClass, this::isAlive, () -> this.unregisterGlobal(eventConsumer));
}
}
private void unregisterGlobal(@Nonnull AsyncEventConsumer<EventType> consumer) {
if (this.shutdown) {
throw new IllegalArgumentException("EventRegistry is shutdown!");
} else if (!((AsyncEventConsumerMap)this.global).remove(consumer)) {
throw new IllegalArgumentException(String.valueOf(consumer));
}
}
@Nonnull
public EventRegistration<KeyType, EventType> registerAsyncUnhandled(short priority, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
return this.registerAsyncUnhandled0(priority, function, function.toString());
}
@Nonnull
private EventRegistration<KeyType, EventType> registerAsyncUnhandled0(short priority, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function, @Nonnull String consumerString) {
if (this.shutdown) {
throw new IllegalArgumentException("EventRegistry is shutdown!");
} else {
AsyncEventConsumer<EventType> eventConsumer = new AsyncEventConsumer<EventType>(priority, consumerString, function);
((AsyncEventConsumerMap)this.unhandled).add(eventConsumer);
return new EventRegistration<KeyType, EventType>(this.eventClass, this::isAlive, () -> this.unregisterUnhandled(eventConsumer));
}
}
private void unregisterUnhandled(@Nonnull AsyncEventConsumer<EventType> consumer) {
if (this.shutdown) {
throw new IllegalArgumentException("EventRegistry is shutdown!");
} else if (!((AsyncEventConsumerMap)this.unhandled).remove(consumer)) {
throw new IllegalArgumentException(String.valueOf(consumer));
}
}
private CompletableFuture<EventType> dispatchGlobal(@Nonnull CompletableFuture<EventType> future) {
return this.dispatchEventMap(future, this.global, "Failed to dispatch event (global)");
}
private CompletableFuture<EventType> dispatchUnhandled(@Nonnull CompletableFuture<EventType> future) {
return this.dispatchEventMap(future, this.unhandled, "Failed to dispatch event (unhandled)");
}
private CompletableFuture<EventType> dispatchEventMap(@Nonnull CompletableFuture<EventType> future, @Nonnull AsyncEventConsumerMap<EventType> eventMap, @Nonnull String s) {
for(short priority : eventMap.getPriorities()) {
List<AsyncEventConsumer<EventType>> consumers = eventMap.get(priority);
if (consumers != null) {
for(AsyncEventConsumer<EventType> consumer : consumers) {
try {
Function<CompletableFuture<EventType>, CompletableFuture<EventType>> theConsumer = this.timeEvents ? consumer.getTimedFunction() : consumer.getFunction();
future = ((CompletableFuture)theConsumer.apply(future)).whenComplete((event, throwable) -> {
if (event instanceof IProcessedEvent processedEvent) {
processedEvent.processEvent(consumer.getConsumerString());
}
if (throwable != null) {
((HytaleLogger.Api)this.logger.at(Level.SEVERE).withCause(throwable)).log("%s %s to %s", s, event, consumer);
}
});
} catch (Throwable t) {
((HytaleLogger.Api)this.logger.at(Level.SEVERE).withCause(t)).log("%s %s to %s", s, future, consumer);
}
}
}
}
return future;
}
@Nonnull
public EventRegistration<KeyType, EventType> register(short priority, KeyType key, @Nonnull Consumer<EventType> consumer) {
return this.registerAsync0(priority, key, (f) -> f.thenApply((e) -> {
consumer.accept(e);
return e;
}), consumer.toString());
}
@Nonnull
public EventRegistration<KeyType, EventType> registerGlobal(short priority, @Nonnull Consumer<EventType> consumer) {
return this.registerAsyncGlobal0(priority, (f) -> f.thenApply((e) -> {
consumer.accept(e);
return e;
}), consumer.toString());
}
@Nonnull
public EventRegistration<KeyType, EventType> registerUnhandled(short priority, @Nonnull Consumer<EventType> consumer) {
return this.registerAsyncUnhandled0(priority, (f) -> f.thenApply((e) -> {
consumer.accept(e);
return e;
}), consumer.toString());
}
@Nonnull
public IEventDispatcher<EventType, CompletableFuture<EventType>> dispatchFor(@Nullable KeyType key) {
if (this.shutdown) {
throw new IllegalArgumentException("EventRegistry is shutdown!");
} else {
KeyType k = (KeyType)(key != null ? key : NULL);
AsyncEventConsumerMap<EventType> eventMap = (AsyncEventConsumerMap)this.map.get(k);
if (eventMap != null && !eventMap.isEmpty()) {
return eventMap;
} else {
return ((AsyncEventConsumerMap)this.global).isEmpty() && ((AsyncEventConsumerMap)this.unhandled).isEmpty() ? NO_OP : this.globalDispatcher;
}
}
}
protected static class AsyncEventConsumer<EventType extends IAsyncEvent> extends EventBusRegistry.EventConsumer {
@Nonnull
private final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function;
@Nonnull
private final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> timedFunction;
public AsyncEventConsumer(short priority, @Nonnull String consumerString, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
super(priority, consumerString);
this.function = function;
this.timedFunction = (f) -> {
long before = System.nanoTime();
return ((CompletableFuture)function.apply(f)).whenComplete((eventType, throwable) -> {
long after = System.nanoTime();
this.timer.add(after - before);
if (throwable != null) {
throw SneakyThrow.sneakyThrow(throwable);
}
});
};
}
@Nonnull
public Function<CompletableFuture<EventType>, CompletableFuture<EventType>> getFunction() {
return this.function;
}
@Nonnull
public Function<CompletableFuture<EventType>, CompletableFuture<EventType>> getTimedFunction() {
return this.timedFunction;
}
@Nonnull
public String toString() {
String var10000 = String.valueOf(this.function);
return "AsyncEventConsumer{function=" + var10000 + ", timedFunction=" + String.valueOf(this.timedFunction) + "} " + super.toString();
}
}
protected static class AsyncEventConsumerMap<EventType extends IAsyncEvent> extends EventBusRegistry.EventConsumerMap<EventType, AsyncEventConsumer<EventType>, CompletableFuture<EventType>> {
protected AsyncEventBusRegistry registry;
public AsyncEventConsumerMap(AsyncEventBusRegistry registry) {
this.registry = registry;
}
@Nonnull
public CompletableFuture<EventType> dispatch(EventType event) {
return CompletableFuture.completedFuture(event).thenComposeAsync(this::dispatch0);
}
private CompletableFuture<EventType> dispatch0(EventType event) {
CompletableFuture<EventType> future = CompletableFuture.completedFuture(event);
CompletableFuture<EventType> before = future;
future = this.registry.dispatchEventMap(future, this, "Failed to dispatch event");
CompletableFuture<EventType> beforeGlobal = future;
future = this.registry.dispatchGlobal(future);
if (beforeGlobal == future && before == beforeGlobal) {
future = this.registry.dispatchUnhandled(future);
}
return future;
}
}
}
com/hypixel/hytale/event/EventBus.java
package com.hypixel.hytale.event;
import com.hypixel.hytale.logger.HytaleLogger;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class EventBus implements IEventBus {
@Nonnull
private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
@Nonnull
private final Map<Class<? extends IBaseEvent<?>>, EventBusRegistry<?, ?, ?>> registryMap = new ConcurrentHashMap();
private final boolean timeEvents;
public EventBus(boolean timeEvents) {
this.timeEvents = timeEvents;
}
public void shutdown() {
this.registryMap.values().forEach(EventBusRegistry::shutdown);
}
@Nonnull
Set<Class<? <?>>> getRegisteredEventClasses() {
(.registryMap.keySet());
}
Set<String> {
Set<String> classNames = ();
(Class<?> aClass : .registryMap.keySet()) {
classNames.add(aClass.getSimpleName());
}
classNames;
}
EventBusRegistry<?, ?, ?> getRegistry( String eventName) {
Class<? > eventClass = ;
(Class<? <?>> aClass : .registryMap.keySet()) {
(aClass.getSimpleName().equalsIgnoreCase(eventName) || aClass.getName().equalsIgnoreCase(eventName)) {
eventClass = aClass;
}
}
eventClass == ? : .getRegistry(eventClass);
}
<KeyType, EventType <KeyType>> EventBusRegistry<KeyType, EventType, ?> getRegistry( Class<? EventType> eventClass) {
(EventBusRegistry<KeyType, EventType, ?>)(IAsyncEvent.class.isAssignableFrom(eventClass) ? .getAsyncRegistry(eventClass) : .getSyncRegistry(eventClass));
}
<KeyType, EventType <KeyType>> EventBusRegistry<KeyType, EventType, ?> getSyncRegistry( Class<? EventType> eventClass) {
EventBusRegistry<?, ? <?>, ? .EventConsumerMap<? <?>, ?, ?>> registry = (EventBusRegistry).registryMap.computeIfAbsent(eventClass, (aClass) -> (LOGGER, aClass));
(.timeEvents) {
registry.setTimeEvents();
}
registry;
}
<KeyType, EventType <KeyType>> AsyncEventBusRegistry<KeyType, EventType> {
EventBusRegistry<?, ? <?>, ? .EventConsumerMap<? <?>, ?, ?>> registry = (EventBusRegistry).registryMap.computeIfAbsent(eventClass, (aClass) -> (LOGGER, aClass));
(.timeEvents) {
registry.setTimeEvents();
}
(AsyncEventBusRegistry)registry;
}
<EventType <Void>> EventRegistration<Void, EventType> {
.<Void, EventType>register((), eventClass, (Object), consumer);
}
<EventType <Void>> EventRegistration<Void, EventType> {
.<Void, EventType>register(priority.getValue(), eventClass, (Object), consumer);
}
<EventType <Void>> EventRegistration<Void, EventType> {
.<Void, EventType>register(priority, eventClass, (Object), consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>register((), eventClass, key, consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>register(priority.getValue(), eventClass, key, consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.getRegistry(eventClass).register(priority, key, consumer);
}
<EventType <Void>> EventRegistration<Void, EventType> {
.<Void, EventType>registerAsync((), eventClass, (Object), function);
}
<EventType <Void>> EventRegistration<Void, EventType> {
.<Void, EventType>registerAsync(priority.getValue(), eventClass, (Object), function);
}
<EventType <Void>> EventRegistration<Void, EventType> {
.<Void, EventType>registerAsync(priority, eventClass, (Object), function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerAsync((), eventClass, key, function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerAsync(priority.getValue(), eventClass, key, function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>getAsyncRegistry(eventClass).registerAsync(priority, key, function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerGlobal((), eventClass, consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerGlobal(priority.getValue(), eventClass, consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.getRegistry(eventClass).registerGlobal(priority, consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerAsyncGlobal((), eventClass, function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerAsyncGlobal(priority.getValue(), eventClass, function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>getAsyncRegistry(eventClass).registerAsyncGlobal(priority, function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerUnhandled((), eventClass, consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerUnhandled(priority.getValue(), eventClass, consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.getRegistry(eventClass).registerUnhandled(priority, consumer);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerAsyncUnhandled((), eventClass, function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>registerAsyncUnhandled(priority.getValue(), eventClass, function);
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.<KeyType, EventType>getAsyncRegistry(eventClass).registerAsyncUnhandled(priority, function);
}
<KeyType, EventType <KeyType>> IEventDispatcher<EventType, EventType> {
SyncEventBusRegistry<KeyType, EventType> registry = (SyncEventBusRegistry).registryMap.get(eventClass);
registry == ? SyncEventBusRegistry.NO_OP : registry.dispatchFor(key);
}
<KeyType, EventType <KeyType>> IEventDispatcher<EventType, CompletableFuture<EventType>> {
AsyncEventBusRegistry<KeyType, EventType> registry = (AsyncEventBusRegistry).registryMap.get(eventClass);
registry == ? AsyncEventBusRegistry.NO_OP : registry.dispatchFor(key);
}
}
com/hypixel/hytale/event/EventBusRegistry.java
package com.hypixel.hytale.event;
import com.hypixel.fastutil.shorts.Short2ObjectConcurrentHashMap;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.metrics.metric.Metric;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public abstract class EventBusRegistry<KeyType, EventType extends IBaseEvent<KeyType>, ConsumerMapType extends EventBusRegistry.EventConsumerMap<EventType, ?, ?>> {
@Nonnull
protected static final Object NULL = new Object();
@Nonnull
protected final HytaleLogger logger;
@Nonnull
protected final Class<EventType> eventClass;
@Nonnull
protected final Map<KeyType, ConsumerMapType> map = new ConcurrentHashMap();
ConsumerMapType global;
ConsumerMapType unhandled;
timeEvents;
shutdown;
{
.logger = logger;
.eventClass = eventClass;
.global = global;
.unhandled = unhandled;
}
Class<EventType> {
.eventClass;
}
{
.timeEvents;
}
{
.timeEvents = timeEvents;
}
{
.shutdown = ;
.map.clear();
}
{
!.shutdown;
}
EventRegistration<KeyType, EventType> ;
EventRegistration<KeyType, EventType> ;
EventRegistration<KeyType, EventType> ;
IEventDispatcher<EventType, ?> dispatchFor(KeyType var1);
{
();
index;
priority;
String consumerString;
();
{
.priority = priority;
.consumerString = consumerString;
.index = consumerIndex.getAndIncrement();
}
{
.index;
}
{
.priority;
}
String {
.consumerString;
}
Metric {
.timer;
}
String {
.index;
+ var10000 + + .priority + + .consumerString + + String.valueOf(.timer) + ;
}
}
<EventType , ConsumerType , ReturnType> <EventType, ReturnType> {
[] EMPTY_SHORT_ARRAY = [];
AtomicReference<[]> prioritiesRef;
Short2ObjectConcurrentHashMap<List<ConsumerType>> map;
{
.prioritiesRef = (EMPTY_SHORT_ARRAY);
.map = <List<ConsumerType>>(, ()-);
}
{
.map.isEmpty();
}
{
eventConsumer.getPriority();
[] wasPriorityAdded = []{};
((List).map.computeIfAbsent(priority, (s) -> {
wasPriorityAdded[] = ;
();
})).add(eventConsumer);
(wasPriorityAdded[]) {
.addPriority(priority);
}
}
{
consumer.getPriority();
[] wasRemoved = []{, };
.map.computeIfPresent(priority, (key, obj) -> {
wasRemoved[] = obj.remove(consumer);
(!obj.isEmpty()) {
obj;
} {
wasRemoved[] = ;
;
}
});
(wasRemoved[]) {
.removePriority(priority);
}
wasRemoved[];
}
[] getPriorities() {
([]).prioritiesRef.get();
}
List<ConsumerType> {
.map.get(priority);
}
{
(.map.containsKey(priority)) {
[] currentPriorities = ([]).prioritiesRef.get();
Arrays.binarySearch(currentPriorities, priority);
(index >= ) {
;
}
-(index + );
currentPriorities.length + ;
[] newPriorities = [newLength];
System.arraycopy(currentPriorities, , newPriorities, , insertionPoint);
newPriorities[insertionPoint] = priority;
System.arraycopy(currentPriorities, insertionPoint, newPriorities, insertionPoint + , currentPriorities.length - insertionPoint);
(.prioritiesRef.compareAndSet(currentPriorities, newPriorities)) {
;
}
}
}
{
(!.map.containsKey(priority)) {
[] currentPriorities = ([]).prioritiesRef.get();
Arrays.binarySearch(currentPriorities, priority);
(index < ) {
;
}
currentPriorities.length - ;
[] newPriorities = [newLength];
System.arraycopy(currentPriorities, , newPriorities, , index);
System.arraycopy(currentPriorities, index + , newPriorities, index, newLength - index);
(.prioritiesRef.compareAndSet(currentPriorities, newPriorities)) {
;
}
}
}
}
}
com/hypixel/hytale/event/EventPriority.java
package com.hypixel.hytale.event;
public enum EventPriority {
FIRST((short)-21844),
EARLY((short)-10922),
NORMAL((short)0),
LATE((short)10922),
LAST((short)21844);
private final short value;
private EventPriority(final short value) {
this.value = value;
}
public short getValue() {
return this.value;
}
}
com/hypixel/hytale/event/EventRegistration.java
package com.hypixel.hytale.event;
import com.hypixel.hytale.registry.Registration;
import java.util.function.BooleanSupplier;
import javax.annotation.Nonnull;
public class EventRegistration<KeyType, EventType extends IBaseEvent<KeyType>> extends Registration {
@Nonnull
protected final Class<EventType> eventClass;
public EventRegistration(@Nonnull Class<EventType> eventClass, @Nonnull BooleanSupplier isEnabled, @Nonnull Runnable unregister) {
super(isEnabled, unregister);
this.eventClass = eventClass;
}
public EventRegistration(@Nonnull EventRegistration<KeyType, EventType> registration, @Nonnull BooleanSupplier isEnabled, @Nonnull Runnable unregister) {
super(isEnabled, unregister);
this.eventClass = registration.eventClass;
}
@Nonnull
public Class<EventType> getEventClass() {
return this.eventClass;
}
@Nonnull
public String toString() {
String var10000 = String.valueOf(.eventClass);
+ var10000 + + .toString() + ;
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
<KeyType, EventType>(thisRegistration.eventClass, () -> {
(!thisRegistration.isEnabled.getAsBoolean()) {
;
} {
(EventRegistration<KeyType, EventType> containerRegistration : containerRegistrations) {
(!containerRegistration.isEnabled.getAsBoolean()) {
;
}
}
;
}
}, () -> {
thisRegistration.unregister();
(EventRegistration<KeyType, EventType> containerRegistration : containerRegistrations) {
containerRegistration.unregister();
}
});
}
}
com/hypixel/hytale/event/EventRegistry.java
package com.hypixel.hytale.event;
import com.hypixel.hytale.function.consumer.BooleanConsumer;
import com.hypixel.hytale.registry.Registry;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.function.Function;
import javax.annotation.Nonnull;
public class EventRegistry extends Registry<EventRegistration<?, ?>> implements IEventRegistry {
@Nonnull
private final IEventRegistry parent;
public EventRegistry(@Nonnull List<BooleanConsumer> registrations, @Nonnull BooleanSupplier precondition, String preconditionMessage, @Nonnull IEventRegistry parent) {
super(registrations, precondition, preconditionMessage, EventRegistration::new);
this.parent = parent;
}
@Nonnull
private IEventRegistry getParent() {
return this.parent;
}
public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> register(@Nonnull EventRegistration<KeyType, EventType> evt) {
(EventRegistration).register(evt);
}
<EventType <Void>> EventRegistration<Void, EventType> {
.checkPrecondition();
.<Void, EventType>register(.getParent().register(eventClass, consumer));
}
<EventType <Void>> EventRegistration<Void, EventType> {
.checkPrecondition();
.<Void, EventType>register(.getParent().register(priority, eventClass, consumer));
}
<EventType <Void>> EventRegistration<Void, EventType> {
.checkPrecondition();
.<Void, EventType>register(.getParent().register(priority, eventClass, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().register(eventClass, key, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().register(priority, eventClass, key, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().register(priority, eventClass, key, consumer));
}
<EventType <Void>> EventRegistration<Void, EventType> {
.checkPrecondition();
.<Void, EventType>register(.getParent().registerAsync(eventClass, function));
}
<EventType <Void>> EventRegistration<Void, EventType> {
.checkPrecondition();
.<Void, EventType>register(.getParent().registerAsync(priority, eventClass, function));
}
<EventType <Void>> EventRegistration<Void, EventType> {
.checkPrecondition();
.<Void, EventType>register(.getParent().registerAsync(priority, eventClass, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsync(eventClass, key, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsync(priority, eventClass, key, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsync(priority, eventClass, key, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerGlobal(eventClass, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerGlobal(priority, eventClass, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerGlobal(priority, eventClass, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsyncGlobal(eventClass, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsyncGlobal(priority, eventClass, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsyncGlobal(priority, eventClass, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerUnhandled(eventClass, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerUnhandled(priority, eventClass, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerUnhandled(priority, eventClass, consumer));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsyncUnhandled(eventClass, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsyncUnhandled(priority, eventClass, function));
}
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> {
.checkPrecondition();
.<KeyType, EventType>register(.getParent().registerAsyncUnhandled(priority, eventClass, function));
}
}
com/hypixel/hytale/event/IAsyncEvent.java
package com.hypixel.hytale.event;
public interface IAsyncEvent<KeyType> extends IBaseEvent<KeyType> {
}
com/hypixel/hytale/event/IBaseEvent.java
package com.hypixel.hytale.event;
public interface IBaseEvent<KeyType> {
}
com/hypixel/hytale/event/ICancellable.java
package com.hypixel.hytale.event;
public interface ICancellable {
boolean isCancelled();
void setCancelled(boolean var1);
}
com/hypixel/hytale/event/IEvent.java
package com.hypixel.hytale.event;
public interface IEvent<KeyType> extends IBaseEvent<KeyType> {
}
com/hypixel/hytale/event/IEventBus.java
package com.hypixel.hytale.event;
import java.util.concurrent.CompletableFuture;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public interface IEventBus extends IEventRegistry {
default <KeyType, EventType extends IEvent<KeyType>> EventType dispatch(@Nonnull Class<EventType> eventClass) {
return (EventType)(this.dispatchFor(eventClass, (Object)null).dispatch((IBaseEvent)null));
}
default <EventType extends IAsyncEvent<Void>> CompletableFuture<EventType> dispatchAsync(@Nonnull Class<EventType> eventClass) {
return (CompletableFuture)this.dispatchForAsync(eventClass).dispatch((IBaseEvent)null);
}
default <KeyType, EventType extends IEvent<KeyType>> IEventDispatcher<EventType, EventType> dispatchFor(@Nonnull Class<? super EventType> eventClass) {
return this.dispatchFor(eventClass, (Object)null);
}
<KeyType, EventType extends IEvent<KeyType>> IEventDispatcher<EventType, EventType> dispatchFor( Class<? EventType> var1, KeyType var2);
<KeyType, EventType <KeyType>> IEventDispatcher<EventType, CompletableFuture<EventType>> {
.dispatchForAsync(eventClass, (Object));
}
<KeyType, EventType <KeyType>> IEventDispatcher<EventType, CompletableFuture<EventType>> ;
}
com/hypixel/hytale/event/IEventDispatcher.java
package com.hypixel.hytale.event;
import javax.annotation.Nullable;
public interface IEventDispatcher<EventType extends IBaseEvent, ReturnType> {
default boolean hasListener() {
return true;
}
ReturnType dispatch(@Nullable EventType var1);
}
com/hypixel/hytale/event/IEventRegistry.java
package com.hypixel.hytale.event;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public interface IEventRegistry {
@Nullable
<EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(@Nonnull Class<? super EventType> var1, @Nonnull Consumer<EventType> var2);
@Nullable
<EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(@Nonnull EventPriority var1, @Nonnull Class<? super EventType> var2, @Nonnull Consumer<EventType> var3);
@Nullable
<EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(short var1, @Nonnull Class<? super EventType> var2, @Nonnull Consumer<EventType> var3);
@Nullable
<KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> register(@Nonnull Class<? super EventType> var1, @Nonnull KeyType var2, Consumer<EventType> var3);
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<EventType <Void>> EventRegistration<Void, EventType> ;
<EventType <Void>> EventRegistration<Void, EventType> ;
<EventType <Void>> EventRegistration<Void, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
<KeyType, EventType <KeyType>> EventRegistration<KeyType, EventType> ;
}
com/hypixel/hytale/event/IProcessedEvent.java
package com.hypixel.hytale.event;
import javax.annotation.Nonnull;
public interface IProcessedEvent {
void processEvent(@Nonnull String var1);
}
com/hypixel/hytale/event/SyncEventBusRegistry.java
package com.hypixel.hytale.event;
import com.hypixel.hytale.logger.HytaleLogger;
import java.util.List;
import java.util.function.Consumer;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class SyncEventBusRegistry<KeyType, EventType extends IEvent<KeyType>> extends EventBusRegistry<KeyType, EventType, SyncEventConsumerMap<EventType>> {
public static final IEventDispatcher NO_OP = new IEventDispatcher<IBaseEvent, IBaseEvent>() {
public boolean hasListener() {
return false;
}
public IBaseEvent dispatch(IBaseEvent event) {
return event;
}
};
private final IEventDispatcher<EventType, EventType> globalDispatcher = (event) -> {
if (!this.dispatchGlobal(event)) {
this.dispatchUnhandled(event);
}
return event;
};
public SyncEventBusRegistry(HytaleLogger logger, Class<EventType> eventClass) {
super(logger, eventClass, ((SyncEventBusRegistry)), ((SyncEventBusRegistry)));
(.global).registry = (.unhandled).registry = ;
}
EventRegistration<KeyType, EventType> {
(.shutdown) {
();
} {
(KeyType)(key != ? key : NULL);
SyncEventConsumerMap<EventType> eventMap = (SyncEventConsumerMap).map.computeIfAbsent(k, (o) -> ());
SyncEventConsumer<EventType> eventConsumer = <EventType>(priority, consumer);
eventMap.add(eventConsumer);
<KeyType, EventType>(.eventClass, ::isAlive, () -> .unregister(key, eventConsumer));
}
}
{
(.shutdown) {
();
} {
(KeyType)(key != ? key : NULL);
SyncEventConsumerMap<EventType> eventMap = (SyncEventConsumerMap).map.get(k);
(eventMap != && !eventMap.remove(consumer)) {
(String.valueOf(consumer));
}
}
}
EventRegistration<KeyType, EventType> {
(.shutdown) {
();
} {
SyncEventConsumer<EventType> eventConsumer = <EventType>(priority, consumer);
((SyncEventConsumerMap).global).add(eventConsumer);
<KeyType, EventType>(.eventClass, ::isAlive, () -> .unregisterGlobal(eventConsumer));
}
}
{
(.shutdown) {
();
} (!((SyncEventConsumerMap).global).remove(consumer)) {
(String.valueOf(consumer));
}
}
EventRegistration<KeyType, EventType> {
(.shutdown) {
();
} {
SyncEventConsumer<EventType> eventConsumer = <EventType>(priority, consumer);
((SyncEventConsumerMap).unhandled).add(eventConsumer);
<KeyType, EventType>(.eventClass, ::isAlive, () -> .unregisterUnhandled(eventConsumer));
}
}
{
(.shutdown) {
();
} (!((SyncEventConsumerMap).unhandled).remove(consumer)) {
(String.valueOf(consumer));
}
}
IEventDispatcher<EventType, EventType> {
(.shutdown) {
();
} {
(KeyType)(key != ? key : NULL);
SyncEventConsumerMap<EventType> eventMap = (SyncEventConsumerMap).map.get(k);
(eventMap != && !eventMap.isEmpty()) {
eventMap;
} {
((SyncEventConsumerMap).global).isEmpty() && ((SyncEventConsumerMap).unhandled).isEmpty() ? NO_OP : .globalDispatcher;
}
}
}
{
.dispatchEventMap(event, .global, );
}
{
.dispatchEventMap(event, .unhandled, );
}
{
;
( priority : eventMap.getPriorities()) {
List<SyncEventConsumer<EventType>> consumers = eventMap.get(priority);
(consumers != ) {
(SyncEventConsumer<EventType> consumer : consumers) {
{
Consumer<EventType> theConsumer = .timeEvents ? consumer.getTimedConsumer() : consumer.getConsumer();
theConsumer.accept(event);
(event IProcessedEvent) {
(IProcessedEvent)event;
processedEvent.processEvent(consumer.getConsumerString());
}
handled = ;
} (Throwable t) {
((HytaleLogger.Api).logger.at(Level.SEVERE).withCause(t)).log(, s, event, consumer);
}
}
}
}
handled;
}
<EventType > .EventConsumer {
Consumer<EventType> consumer;
Consumer<EventType> timedConsumer;
{
(priority, consumer.toString());
.consumer = consumer;
.timedConsumer = (t) -> {
System.nanoTime();
consumer.accept(t);
System.nanoTime();
.timer.add(after - before);
};
}
Consumer<EventType> {
.consumer;
}
Consumer<EventType> {
.timedConsumer;
}
String {
String.valueOf(.consumer);
+ var10000 + + String.valueOf(.timedConsumer) + + .toString();
}
}
<EventType > .EventConsumerMap<EventType, SyncEventConsumer<EventType>, EventType> {
SyncEventBusRegistry registry;
{
.registry = registry;
}
EventType {
.registry.dispatchEventMap(event, , );
(!.registry.dispatchGlobal(event) && !handled) {
.registry.dispatchUnhandled(event);
}
event;
}
}
}