View Javadoc

    1   /*
    2    * Copyright 2012 The Netty Project
    3    *
    4    * The Netty Project licenses this file to you under the Apache License,
    5    * version 2.0 (the "License"); you may not use this file except in compliance
    6    * with the License. You may obtain a copy of the License at:
    7    *
    8    *   http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
    13   * License for the specific language governing permissions and limitations
    14   * under the License.
    15   */
    16  package org.jboss.netty.channel.socket;
    17
    18  import java.net.Socket;
    19  import java.net.SocketException;
    20
    21  import org.jboss.netty.channel.ChannelException;
    22  import org.jboss.netty.channel.DefaultChannelConfig;
    23  import org.jboss.netty.util.internal.ConversionUtil;
    24
    25  /**
    26   * The default {@link SocketChannelConfig} implementation.
    27   */
    28  public class DefaultSocketChannelConfig extends DefaultChannelConfig
    29                                          implements SocketChannelConfig {
    30
    31      private final Socket socket;
    32
    33      /**
    34       * Creates a new instance.
    35       */
    36      public DefaultSocketChannelConfig(Socket socket) {
    37          if (socket == null) {
    38              throw new NullPointerException("socket");
    39          }
    40          this.socket = socket;
    41      }
    42
    43      @Override
    44      public boolean setOption(String key, Object value) {
    45          if (super.setOption(key, value)) {
    46              return true;
    47          }
    48
    49          if (key.equals("receiveBufferSize")) {
    50              setReceiveBufferSize(ConversionUtil.toInt(value));
    51          } else if (key.equals("sendBufferSize")) {
    52              setSendBufferSize(ConversionUtil.toInt(value));
    53          } else if (key.equals("tcpNoDelay")) {
    54              setTcpNoDelay(ConversionUtil.toBoolean(value));
    55          } else if (key.equals("keepAlive")) {
    56              setKeepAlive(ConversionUtil.toBoolean(value));
    57          } else if (key.equals("reuseAddress")) {
    58              setReuseAddress(ConversionUtil.toBoolean(value));
    59          } else if (key.equals("soLinger")) {
    60              setSoLinger(ConversionUtil.toInt(value));
    61          } else if (key.equals("trafficClass")) {
    62              setTrafficClass(ConversionUtil.toInt(value));
    63          } else {
    64              return false;
    65          }
    66          return true;
    67      }
    68
    69      public int getReceiveBufferSize() {
    70          try {
    71              return socket.getReceiveBufferSize();
    72          } catch (SocketException e) {
    73              throw new ChannelException(e);
    74          }
    75      }
    76
    77      public int getSendBufferSize() {
    78          try {
    79              return socket.getSendBufferSize();
    80          } catch (SocketException e) {
    81              throw new ChannelException(e);
    82          }
    83      }
    84
    85      public int getSoLinger() {
    86          try {
    87              return socket.getSoLinger();
    88          } catch (SocketException e) {
    89              throw new ChannelException(e);
    90          }
    91      }
    92
    93      public int getTrafficClass() {
    94          try {
    95              return socket.getTrafficClass();
    96          } catch (SocketException e) {
    97              throw new ChannelException(e);
    98          }
    99      }
    100
    101     public boolean isKeepAlive() {
    102         try {
    103             return socket.getKeepAlive();
    104         } catch (SocketException e) {
    105             throw new ChannelException(e);
    106         }
    107     }
    108
    109     public boolean isReuseAddress() {
    110         try {
    111             return socket.getReuseAddress();
    112         } catch (SocketException e) {
    113             throw new ChannelException(e);
    114         }
    115     }
    116
    117     public boolean isTcpNoDelay() {
    118         try {
    119             return socket.getTcpNoDelay();
    120         } catch (SocketException e) {
    121             throw new ChannelException(e);
    122         }
    123     }
    124
    125     public void setKeepAlive(boolean keepAlive) {
    126         try {
    127             socket.setKeepAlive(keepAlive);
    128         } catch (SocketException e) {
    129             throw new ChannelException(e);
    130         }
    131     }
    132
    133     public void setPerformancePreferences(
    134             int connectionTime, int latency, int bandwidth) {
    135         socket.setPerformancePreferences(connectionTime, latency, bandwidth);
    136     }
    137
    138     public void setReceiveBufferSize(int receiveBufferSize) {
    139         try {
    140             socket.setReceiveBufferSize(receiveBufferSize);
    141         } catch (SocketException e) {
    142             throw new ChannelException(e);
    143         }
    144     }
    145
    146     public void setReuseAddress(boolean reuseAddress) {
    147         try {
    148             socket.setReuseAddress(reuseAddress);
    149         } catch (SocketException e) {
    150             throw new ChannelException(e);
    151         }
    152     }
    153
    154     public void setSendBufferSize(int sendBufferSize) {
    155         try {
    156             socket.setSendBufferSize(sendBufferSize);
    157         } catch (SocketException e) {
    158             throw new ChannelException(e);
    159         }
    160     }
    161
    162     public void setSoLinger(int soLinger) {
    163         try {
    164             if (soLinger < 0) {
    165                 socket.setSoLinger(false, 0);
    166             } else {
    167                 socket.setSoLinger(true, soLinger);
    168             }
    169         } catch (SocketException e) {
    170             throw new ChannelException(e);
    171         }
    172     }
    173
    174     public void setTcpNoDelay(boolean tcpNoDelay) {
    175         try {
    176             socket.setTcpNoDelay(tcpNoDelay);
    177         } catch (SocketException e) {
    178             throw new ChannelException(e);
    179         }
    180     }
    181
    182     public void setTrafficClass(int trafficClass) {
    183         try {
    184             socket.setTrafficClass(trafficClass);
    185         } catch (SocketException e) {
    186             throw new ChannelException(e);
    187         }
    188     }
    189 }