// 
// Decompiled by Procyon v0.6.0
// 

package com.hypixel.hytale.event;

import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import java.util.function.Consumer;
import java.util.function.BooleanSupplier;
import com.hypixel.hytale.function.consumer.BooleanConsumer;
import java.util.List;
import javax.annotation.Nonnull;
import com.hypixel.hytale.registry.Registry;

public class EventRegistry extends Registry<EventRegistration<?, ?>> implements IEventRegistry
{
    @Nonnull
    private final IEventRegistry parent;
    
    public EventRegistry(@Nonnull final List<BooleanConsumer> registrations, @Nonnull final BooleanSupplier precondition, final String preconditionMessage, @Nonnull final IEventRegistry parent) {
        super(registrations, precondition, preconditionMessage, EventRegistration::new);
        this.parent = parent;
    }
    
    @Nonnull
    private IEventRegistry getParent() {
        return this.parent;
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> register(@Nonnull final EventRegistration<KeyType, EventType> evt) {
        return (EventRegistration)super.register(evt);
    }
    
    @Override
    public <EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(@Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<Void, EventType>)this.getParent().register((Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(@Nonnull final EventPriority priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<Void, EventType>)this.getParent().register(priority, (Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(final short priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<Void, EventType>)this.getParent().register(priority, (Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> register(@Nonnull final Class<? super EventType> eventClass, @Nonnull final KeyType key, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().register((Class<? super EventType>)eventClass, (KeyType)key, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> register(@Nonnull final EventPriority priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final KeyType key, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().register(priority, (Class<? super EventType>)eventClass, (KeyType)key, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> register(final short priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final KeyType key, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().register(priority, (Class<? super EventType>)eventClass, (KeyType)key, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <EventType extends IAsyncEvent<Void>> EventRegistration<Void, EventType> registerAsync(@Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<Void, EventType>)this.getParent().registerAsync((Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <EventType extends IAsyncEvent<Void>> EventRegistration<Void, EventType> registerAsync(@Nonnull final EventPriority priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<Void, EventType>)this.getParent().registerAsync(priority, (Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <EventType extends IAsyncEvent<Void>> EventRegistration<Void, EventType> registerAsync(final short priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<Void, EventType>)this.getParent().registerAsync(priority, (Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsync(@Nonnull final Class<? super EventType> eventClass, @Nonnull final KeyType key, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsync((Class<? super EventType>)eventClass, (KeyType)key, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsync(@Nonnull final EventPriority priority, final Class<? super EventType> eventClass, @Nonnull final KeyType key, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsync(priority, (Class<? super EventType>)eventClass, (KeyType)key, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsync(final short priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final KeyType key, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsync(priority, (Class<? super EventType>)eventClass, (KeyType)key, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> registerGlobal(@Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerGlobal((Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> registerGlobal(@Nonnull final EventPriority priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerGlobal(priority, (Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> registerGlobal(final short priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerGlobal(priority, (Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsyncGlobal(@Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsyncGlobal((Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsyncGlobal(@Nonnull final EventPriority priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsyncGlobal(priority, (Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsyncGlobal(final short priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsyncGlobal(priority, (Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> registerUnhandled(@Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerUnhandled((Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> registerUnhandled(@Nonnull final EventPriority priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerUnhandled(priority, (Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> registerUnhandled(final short priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Consumer<EventType> consumer) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerUnhandled(priority, (Class<? super EventType>)eventClass, (Consumer<EventType>)consumer));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsyncUnhandled(@Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsyncUnhandled((Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsyncUnhandled(@Nonnull final EventPriority priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsyncUnhandled(priority, (Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
    
    @Override
    public <KeyType, EventType extends IAsyncEvent<KeyType>> EventRegistration<KeyType, EventType> registerAsyncUnhandled(final short priority, @Nonnull final Class<? super EventType> eventClass, @Nonnull final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
        this.checkPrecondition();
        return this.register((EventRegistration<KeyType, EventType>)this.getParent().registerAsyncUnhandled(priority, (Class<? super EventType>)eventClass, (Function<CompletableFuture<EventType>, CompletableFuture<EventType>>)function));
    }
}