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

package io.netty.channel.kqueue;

import io.netty.channel.Channel;
import java.util.Iterator;
import java.util.Queue;
import io.netty.channel.SingleThreadIoEventLoop;
import io.netty.util.internal.logging.InternalLoggerFactory;
import io.netty.channel.IoEventLoopGroup;
import io.netty.channel.IoEventLoop;
import io.netty.channel.IoHandlerFactory;
import io.netty.channel.EventLoopTaskQueueFactory;
import io.netty.util.concurrent.RejectedExecutionHandler;
import io.netty.util.concurrent.EventExecutorChooserFactory;
import io.netty.util.concurrent.RejectedExecutionHandlers;
import io.netty.channel.DefaultSelectStrategyFactory;
import java.util.concurrent.Executor;
import io.netty.channel.SelectStrategyFactory;
import java.util.concurrent.ThreadFactory;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.channel.MultiThreadIoEventLoopGroup;

@Deprecated
public final class KQueueEventLoopGroup extends MultiThreadIoEventLoopGroup
{
    private static final InternalLogger LOGGER;
    
    public KQueueEventLoopGroup() {
        this(0);
    }
    
    public KQueueEventLoopGroup(final int nThreads) {
        this(nThreads, (ThreadFactory)null);
    }
    
    public KQueueEventLoopGroup(final ThreadFactory threadFactory) {
        this(0, threadFactory, 0);
    }
    
    public KQueueEventLoopGroup(final int nThreads, final SelectStrategyFactory selectStrategyFactory) {
        this(nThreads, (ThreadFactory)null, selectStrategyFactory);
    }
    
    public KQueueEventLoopGroup(final int nThreads, final ThreadFactory threadFactory) {
        this(nThreads, threadFactory, 0);
    }
    
    public KQueueEventLoopGroup(final int nThreads, final Executor executor) {
        this(nThreads, executor, DefaultSelectStrategyFactory.INSTANCE);
    }
    
    public KQueueEventLoopGroup(final int nThreads, final ThreadFactory threadFactory, final SelectStrategyFactory selectStrategyFactory) {
        this(nThreads, threadFactory, 0, selectStrategyFactory);
    }
    
    @Deprecated
    public KQueueEventLoopGroup(final int nThreads, final ThreadFactory threadFactory, final int maxEventsAtOnce) {
        this(nThreads, threadFactory, maxEventsAtOnce, DefaultSelectStrategyFactory.INSTANCE);
    }
    
    @Deprecated
    public KQueueEventLoopGroup(final int nThreads, final ThreadFactory threadFactory, final int maxEventsAtOnce, final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, threadFactory, KQueueIoHandler.newFactory(maxEventsAtOnce, selectStrategyFactory), new Object[] { RejectedExecutionHandlers.reject() });
        KQueue.ensureAvailability();
    }
    
    public KQueueEventLoopGroup(final int nThreads, final Executor executor, final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, executor, KQueueIoHandler.newFactory(0, selectStrategyFactory), new Object[] { RejectedExecutionHandlers.reject() });
        KQueue.ensureAvailability();
    }
    
    public KQueueEventLoopGroup(final int nThreads, final Executor executor, final EventExecutorChooserFactory chooserFactory, final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, executor, KQueueIoHandler.newFactory(0, selectStrategyFactory), chooserFactory, new Object[] { RejectedExecutionHandlers.reject() });
        KQueue.ensureAvailability();
    }
    
    public KQueueEventLoopGroup(final int nThreads, final Executor executor, final EventExecutorChooserFactory chooserFactory, final SelectStrategyFactory selectStrategyFactory, final RejectedExecutionHandler rejectedExecutionHandler) {
        super(nThreads, executor, KQueueIoHandler.newFactory(0, selectStrategyFactory), chooserFactory, new Object[] { rejectedExecutionHandler });
        KQueue.ensureAvailability();
    }
    
    public KQueueEventLoopGroup(final int nThreads, final Executor executor, final EventExecutorChooserFactory chooserFactory, final SelectStrategyFactory selectStrategyFactory, final RejectedExecutionHandler rejectedExecutionHandler, final EventLoopTaskQueueFactory queueFactory) {
        super(nThreads, executor, KQueueIoHandler.newFactory(0, selectStrategyFactory), chooserFactory, new Object[] { rejectedExecutionHandler, queueFactory });
        KQueue.ensureAvailability();
    }
    
    public KQueueEventLoopGroup(final int nThreads, final Executor executor, final EventExecutorChooserFactory chooserFactory, final SelectStrategyFactory selectStrategyFactory, final RejectedExecutionHandler rejectedExecutionHandler, final EventLoopTaskQueueFactory taskQueueFactory, final EventLoopTaskQueueFactory tailTaskQueueFactory) {
        super(nThreads, executor, KQueueIoHandler.newFactory(0, selectStrategyFactory), chooserFactory, new Object[] { rejectedExecutionHandler, taskQueueFactory, tailTaskQueueFactory });
        KQueue.ensureAvailability();
    }
    
    @Deprecated
    public void setIoRatio(final int ioRatio) {
        KQueueEventLoopGroup.LOGGER.debug("EpollEventLoopGroup.setIoRatio(int) logic was removed, this is a no-op");
    }
    
    @Override
    protected IoEventLoop newChild(final Executor executor, final IoHandlerFactory ioHandlerFactory, final Object... args) {
        RejectedExecutionHandler rejectedExecutionHandler = null;
        EventLoopTaskQueueFactory taskQueueFactory = null;
        EventLoopTaskQueueFactory tailTaskQueueFactory = null;
        final int argsLength = args.length;
        if (argsLength > 0) {
            rejectedExecutionHandler = (RejectedExecutionHandler)args[0];
        }
        if (argsLength > 1) {
            taskQueueFactory = (EventLoopTaskQueueFactory)args[2];
        }
        if (argsLength > 2) {
            tailTaskQueueFactory = (EventLoopTaskQueueFactory)args[1];
        }
        return new KQueueEventLoop(this, executor, ioHandlerFactory, KQueueEventLoop.newTaskQueue(taskQueueFactory), KQueueEventLoop.newTaskQueue(tailTaskQueueFactory), rejectedExecutionHandler);
    }
    
    static {
        LOGGER = InternalLoggerFactory.getInstance(KQueueEventLoopGroup.class);
    }
    
    private static final class KQueueEventLoop extends SingleThreadIoEventLoop
    {
        KQueueEventLoop(final IoEventLoopGroup parent, final Executor executor, final IoHandlerFactory ioHandlerFactory, final Queue<Runnable> taskQueue, final Queue<Runnable> tailTaskQueue, final RejectedExecutionHandler rejectedExecutionHandler) {
            super(parent, executor, ioHandlerFactory, taskQueue, tailTaskQueue, rejectedExecutionHandler);
        }
        
        static Queue<Runnable> newTaskQueue(final EventLoopTaskQueueFactory queueFactory) {
            if (queueFactory == null) {
                return SingleThreadIoEventLoop.newTaskQueue0(KQueueEventLoop.DEFAULT_MAX_PENDING_TASKS);
            }
            return queueFactory.newTaskQueue(KQueueEventLoop.DEFAULT_MAX_PENDING_TASKS);
        }
        
        @Override
        public int registeredChannels() {
            assert this.inEventLoop();
            return ((KQueueIoHandler)this.ioHandler()).numRegisteredChannels();
        }
        
        @Override
        public Iterator<Channel> registeredChannelsIterator() {
            assert this.inEventLoop();
            return ((KQueueIoHandler)this.ioHandler()).registeredChannelsList().iterator();
        }
    }
}