/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.channel.embedded;
import io.netty.channel.
Channel;
import io.netty.channel.
ChannelFuture;
import io.netty.channel.
ChannelPromise;
import io.netty.channel.
DefaultChannelPromise;
import io.netty.channel.
EventLoop;
import io.netty.channel.
EventLoopGroup;
import io.netty.util.concurrent.
AbstractScheduledEventExecutor;
import io.netty.util.concurrent.
Future;
import io.netty.util.internal.
ObjectUtil;
import java.util.
ArrayDeque;
import java.util.
Queue;
import java.util.concurrent.
TimeUnit;
final class
EmbeddedEventLoop extends
AbstractScheduledEventExecutor implements
EventLoop {
private final
Queue<
Runnable>
tasks = new
ArrayDeque<
Runnable>(2);
@
Override
public
EventLoopGroup parent() {
return (
EventLoopGroup) super.parent();
}
@
Override
public
EventLoop next() {
return (
EventLoop) super.next();
}
@
Override
public void
execute(
Runnable command) {
if (
command == null) {
throw new
NullPointerException("command");
}
tasks.
add(
command);
}
void
runTasks() {
for (;;) {
Runnable task =
tasks.
poll();
if (
task == null) {
break;
}
task.
run();
}
}
long
runScheduledTasks() {
long
time =
AbstractScheduledEventExecutor.
nanoTime();
for (;;) {
Runnable task =
pollScheduledTask(
time);
if (
task == null) {
return
nextScheduledTaskNano();
}
task.
run();
}
}
long
nextScheduledTask() {
return
nextScheduledTaskNano();
}
@
Override
protected void
cancelScheduledTasks() {
super.cancelScheduledTasks();
}
@
Override
public
Future<?>
shutdownGracefully(long
quietPeriod, long
timeout,
TimeUnit unit) {
throw new
UnsupportedOperationException();
}
@
Override
public
Future<?>
terminationFuture() {
throw new
UnsupportedOperationException();
}
@
Override
@
Deprecated
public void
shutdown() {
throw new
UnsupportedOperationException();
}
@
Override
public boolean
isShuttingDown() {
return false;
}
@
Override
public boolean
isShutdown() {
return false;
}
@
Override
public boolean
isTerminated() {
return false;
}
@
Override
public boolean
awaitTermination(long
timeout,
TimeUnit unit) {
return false;
}
@
Override
public
ChannelFuture register(
Channel channel) {
return
register(new
DefaultChannelPromise(
channel, this));
}
@
Override
public
ChannelFuture register(
ChannelPromise promise) {
ObjectUtil.
checkNotNull(
promise, "promise");
promise.
channel().
unsafe().
register(this,
promise);
return
promise;
}
@
Deprecated
@
Override
public
ChannelFuture register(
Channel channel,
ChannelPromise promise) {
channel.
unsafe().
register(this,
promise);
return
promise;
}
@
Override
public boolean
inEventLoop() {
return true;
}
@
Override
public boolean
inEventLoop(
Thread thread) {
return true;
}
}