diff --git a/transport/src/main/java/io/netty/channel/socket/nio/NioChannelConfig.java b/transport/src/main/java/io/netty/channel/socket/nio/NioChannelConfig.java
new file mode 100644
index 0000000000..65dd184993
--- /dev/null
+++ b/transport/src/main/java/io/netty/channel/socket/nio/NioChannelConfig.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2011 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.socket.nio;
+
+import java.nio.ByteBuffer;
+import java.nio.channels.WritableByteChannel;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelConfig;
+
+/**
+ * Special {@link ChannelConfig} sub-type which offers extra methods which are useful for NIO.
+ *
+ */
+public interface NioChannelConfig extends ChannelConfig{
+
+ /**
+ * Returns the high water mark of the write buffer. If the number of bytes
+ * queued in the write buffer exceeds this value, {@link Channel#isWritable()}
+ * will start to return {@code true}.
+ */
+ int getWriteBufferHighWaterMark();
+
+ /**
+ * Sets the high water mark of the write buffer. If the number of bytes
+ * queued in the write buffer exceeds this value, {@link Channel#isWritable()}
+ * will start to return {@code true}.
+ */
+ void setWriteBufferHighWaterMark(int writeBufferHighWaterMark);
+
+ /**
+ * Returns the low water mark of the write buffer. Once the number of bytes
+ * queued in the write buffer exceeded the
+ * {@linkplain #setWriteBufferHighWaterMark(int) high water mark} and then
+ * dropped down below this value, {@link Channel#isWritable()} will return
+ * {@code false} again.
+ */
+ int getWriteBufferLowWaterMark();
+
+ /**
+ * Sets the low water mark of the write buffer. Once the number of bytes
+ * queued in the write buffer exceeded the
+ * {@linkplain #setWriteBufferHighWaterMark(int) high water mark} and then
+ * dropped down below this value, {@link Channel#isWritable()} will return
+ * {@code false} again.
+ */
+ void setWriteBufferLowWaterMark(int writeBufferLowWaterMark);
+
+ /**
+ * Returns the maximum loop count for a write operation until
+ * {@link WritableByteChannel#write(ByteBuffer)} returns a non-zero value.
+ * It is similar to what a spin lock is used for in concurrency programming.
+ * It improves memory utilization and write throughput depending on
+ * the platform that JVM runs on. The default value is {@code 16}.
+ */
+ int getWriteSpinCount();
+
+ /**
+ * Sets the maximum loop count for a write operation until
+ * {@link WritableByteChannel#write(ByteBuffer)} returns a non-zero value.
+ * It is similar to what a spin lock is used for in concurrency programming.
+ * It improves memory utilization and write throughput depending on
+ * the platform that JVM runs on. The default value is {@code 16}.
+ *
+ * @throws IllegalArgumentException
+ * if the specified value is {@code 0} or less than {@code 0}
+ */
+ void setWriteSpinCount(int writeSpinCount);
+}
diff --git a/transport/src/main/java/io/netty/channel/socket/nio/NioDatagramChannelConfig.java b/transport/src/main/java/io/netty/channel/socket/nio/NioDatagramChannelConfig.java
index 153971a208..486ba68815 100644
--- a/transport/src/main/java/io/netty/channel/socket/nio/NioDatagramChannelConfig.java
+++ b/transport/src/main/java/io/netty/channel/socket/nio/NioDatagramChannelConfig.java
@@ -15,10 +15,6 @@
*/
package io.netty.channel.socket.nio;
-import java.nio.ByteBuffer;
-import java.nio.channels.WritableByteChannel;
-
-import io.netty.channel.Channel;
import io.netty.channel.ChannelConfig;
import io.netty.channel.socket.DatagramChannel;
import io.netty.channel.socket.DatagramChannelConfig;
@@ -44,58 +40,7 @@ import io.netty.channel.socket.DatagramChannelConfig;
*
*
*/
-public interface NioDatagramChannelConfig extends DatagramChannelConfig {
+public interface NioDatagramChannelConfig extends DatagramChannelConfig, NioChannelConfig {
- /**
- * Returns the high water mark of the write buffer. If the number of bytes
- * queued in the write buffer exceeds this value, {@link Channel#isWritable()}
- * will start to return {@code true}.
- */
- int getWriteBufferHighWaterMark();
- /**
- * Sets the high water mark of the write buffer. If the number of bytes
- * queued in the write buffer exceeds this value, {@link Channel#isWritable()}
- * will start to return {@code true}.
- */
- void setWriteBufferHighWaterMark(int writeBufferHighWaterMark);
-
- /**
- * Returns the low water mark of the write buffer. Once the number of bytes
- * queued in the write buffer exceeded the
- * {@linkplain #setWriteBufferHighWaterMark(int) high water mark} and then
- * dropped down below this value, {@link Channel#isWritable()} will return
- * {@code false} again.
- */
- int getWriteBufferLowWaterMark();
-
- /**
- * Sets the low water mark of the write buffer. Once the number of bytes
- * queued in the write buffer exceeded the
- * {@linkplain #setWriteBufferHighWaterMark(int) high water mark} and then
- * dropped down below this value, {@link Channel#isWritable()} will return
- * {@code false} again.
- */
- void setWriteBufferLowWaterMark(int writeBufferLowWaterMark);
-
- /**
- * Returns the maximum loop count for a write operation until
- * {@link WritableByteChannel#write(ByteBuffer)} returns a non-zero value.
- * It is similar to what a spin lock is used for in concurrency programming.
- * It improves memory utilization and write throughput depending on
- * the platform that JVM runs on. The default value is {@code 16}.
- */
- int getWriteSpinCount();
-
- /**
- * Sets the maximum loop count for a write operation until
- * {@link WritableByteChannel#write(ByteBuffer)} returns a non-zero value.
- * It is similar to what a spin lock is used for in concurrency programming.
- * It improves memory utilization and write throughput depending on
- * the platform that JVM runs on. The default value is {@code 16}.
- *
- * @throws IllegalArgumentException
- * if the specified value is {@code 0} or less than {@code 0}
- */
- void setWriteSpinCount(int writeSpinCount);
}
diff --git a/transport/src/main/java/io/netty/channel/socket/nio/NioSocketChannelConfig.java b/transport/src/main/java/io/netty/channel/socket/nio/NioSocketChannelConfig.java
index e949db6293..bb0fd64e62 100644
--- a/transport/src/main/java/io/netty/channel/socket/nio/NioSocketChannelConfig.java
+++ b/transport/src/main/java/io/netty/channel/socket/nio/NioSocketChannelConfig.java
@@ -15,12 +15,8 @@
*/
package io.netty.channel.socket.nio;
-import java.nio.ByteBuffer;
-import java.nio.channels.WritableByteChannel;
-
import io.netty.channel.AdaptiveReceiveBufferSizePredictor;
import io.netty.channel.AdaptiveReceiveBufferSizePredictorFactory;
-import io.netty.channel.Channel;
import io.netty.channel.ChannelConfig;
import io.netty.channel.ReceiveBufferSizePredictor;
import io.netty.channel.ReceiveBufferSizePredictorFactory;
@@ -52,60 +48,8 @@ import io.netty.channel.socket.SocketChannelConfig;
*
*
*/
-public interface NioSocketChannelConfig extends SocketChannelConfig {
+public interface NioSocketChannelConfig extends SocketChannelConfig, NioChannelConfig {
- /**
- * Returns the high water mark of the write buffer. If the number of bytes
- * queued in the write buffer exceeds this value, {@link Channel#isWritable()}
- * will start to return {@code false}.
- */
- int getWriteBufferHighWaterMark();
-
- /**
- * Sets the high water mark of the write buffer. If the number of bytes
- * queued in the write buffer exceeds this value, {@link Channel#isWritable()}
- * will start to return {@code false}.
- */
- void setWriteBufferHighWaterMark(int writeBufferHighWaterMark);
-
- /**
- * Returns the low water mark of the write buffer. Once the number of bytes
- * queued in the write buffer exceeded the
- * {@linkplain #setWriteBufferHighWaterMark(int) high water mark} and then
- * dropped down below this value, {@link Channel#isWritable()} will return
- * {@code true} again.
- */
- int getWriteBufferLowWaterMark();
-
- /**
- * Sets the low water mark of the write buffer. Once the number of bytes
- * queued in the write buffer exceeded the
- * {@linkplain #setWriteBufferHighWaterMark(int) high water mark} and then
- * dropped down below this value, {@link Channel#isWritable()} will return
- * {@code true} again.
- */
- void setWriteBufferLowWaterMark(int writeBufferLowWaterMark);
-
- /**
- * Returns the maximum loop count for a write operation until
- * {@link WritableByteChannel#write(ByteBuffer)} returns a non-zero value.
- * It is similar to what a spin lock is used for in concurrency programming.
- * It improves memory utilization and write throughput depending on
- * the platform that JVM runs on. The default value is {@code 16}.
- */
- int getWriteSpinCount();
-
- /**
- * Sets the maximum loop count for a write operation until
- * {@link WritableByteChannel#write(ByteBuffer)} returns a non-zero value.
- * It is similar to what a spin lock is used for in concurrency programming.
- * It improves memory utilization and write throughput depending on
- * the platform that JVM runs on. The default value is {@code 16}.
- *
- * @throws IllegalArgumentException
- * if the specified value is {@code 0} or less than {@code 0}
- */
- void setWriteSpinCount(int writeSpinCount);
/**
* Returns the {@link ReceiveBufferSizePredictor} which predicts the