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   {
      .registryMap.values().forEach(EventBusRegistry::shutdown);
   }

   
    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);
   }
}