View Javadoc
1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License.
18   *
19   */
20  package org.apache.mina.transport.socket.nio;
21  
22  import java.net.DatagramSocket;
23  import java.net.SocketException;
24  import java.nio.channels.DatagramChannel;
25  
26  import org.apache.mina.core.RuntimeIoException;
27  import org.apache.mina.transport.socket.AbstractDatagramSessionConfig;
28  
29  /**
30   * Define the configuration for a Datagram based session. 
31   * 
32   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
33   */
34  class NioDatagramSessionConfig extends AbstractDatagramSessionConfig {
35      /** The associated channel */
36      private final DatagramChannel channel;
37  
38      /**
39       * Creates a new instance of NioDatagramSessionConfig, associated
40       * with the given DatagramChannel.
41       *
42       * @param channel The associated DatagramChannel
43       */
44      NioDatagramSessionConfig(DatagramChannel channel) {
45          this.channel = channel;
46      }
47  
48      /**
49       * Get the Socket receive buffer size for this DatagramChannel.
50       * 
51       * @return the DatagramChannel receive buffer size.
52       * @throws RuntimeIoException if the socket is closed or if we 
53       * had a SocketException
54       * 
55       * @see DatagramSocket#getReceiveBufferSize()
56       */
57      public int getReceiveBufferSize() {
58          try {
59              return channel.socket().getReceiveBufferSize();
60          } catch (SocketException e) {
61              throw new RuntimeIoException(e);
62          }
63      }
64  
65      /**
66       * Set the Socket receive buffer size for this DatagramChannel. <br>
67       * <br>
68       * Note : The underlying Socket may not accept the new buffer's size.
69       * The user has to check that the new value has been set. 
70       * 
71       * @param receiveBufferSize the DatagramChannel receive buffer size.
72       * @throws RuntimeIoException if the socket is closed or if we 
73       * had a SocketException
74       * 
75       * @see DatagramSocket#setReceiveBufferSize()
76       */
77      public void setReceiveBufferSize(int receiveBufferSize) {
78          try {
79              channel.socket().setReceiveBufferSize(receiveBufferSize);
80          } catch (SocketException e) {
81              throw new RuntimeIoException(e);
82          }
83      }
84  
85      /**
86       * Tells if SO_BROADCAST is enabled.
87       * 
88       * @return <code>true</code> if SO_BROADCAST is enabled
89       * @throws RuntimeIoException If the socket is closed or if we get an
90       * {@link SocketException} 
91       */
92      public boolean isBroadcast() {
93          try {
94              return channel.socket().getBroadcast();
95          } catch (SocketException e) {
96              throw new RuntimeIoException(e);
97          }
98      }
99  
100     public void setBroadcast(boolean broadcast) {
101         try {
102             channel.socket().setBroadcast(broadcast);
103         } catch (SocketException e) {
104             throw new RuntimeIoException(e);
105         }
106     }
107 
108     /**
109      * 
110      * @throws RuntimeIoException If the socket is closed or if we get an
111      * {@link SocketException} 
112      */
113     public int getSendBufferSize() {
114         try {
115             return channel.socket().getSendBufferSize();
116         } catch (SocketException e) {
117             throw new RuntimeIoException(e);
118         }
119     }
120 
121     /**
122      * 
123      * @throws RuntimeIoException If the socket is closed or if we get an
124      * {@link SocketException} 
125      */
126     public void setSendBufferSize(int sendBufferSize) {
127         try {
128             channel.socket().setSendBufferSize(sendBufferSize);
129         } catch (SocketException e) {
130             throw new RuntimeIoException(e);
131         }
132     }
133 
134     /**
135      * Tells if SO_REUSEADDR is enabled.
136      * 
137      * @return <code>true</code> if SO_REUSEADDR is enabled
138      * @throws RuntimeIoException If the socket is closed or if we get an
139      * {@link SocketException} 
140      */
141     public boolean isReuseAddress() {
142         try {
143             return channel.socket().getReuseAddress();
144         } catch (SocketException e) {
145             throw new RuntimeIoException(e);
146         }
147     }
148 
149     /**
150      * 
151      * @throws RuntimeIoException If the socket is closed or if we get an
152      * {@link SocketException} 
153      */
154     public void setReuseAddress(boolean reuseAddress) {
155         try {
156             channel.socket().setReuseAddress(reuseAddress);
157         } catch (SocketException e) {
158             throw new RuntimeIoException(e);
159         }
160     }
161 
162     /**
163      * Get the current Traffic Class for this Socket, if any. As this is
164      * not a mandatory feature, the returned value should be considered as 
165      * a hint. 
166      * 
167      * @return The Traffic Class supported by this Socket
168      * @throws RuntimeIoException If the socket is closed or if we get an
169      * {@link SocketException} 
170      */
171     public int getTrafficClass() {
172         try {
173             return channel.socket().getTrafficClass();
174         } catch (SocketException e) {
175             throw new RuntimeIoException(e);
176         }
177     }
178 
179     /**
180      * {@inheritDoc}
181      * @throws RuntimeIoException If the socket is closed or if we get an
182      * {@link SocketException} 
183      */
184     public void setTrafficClass(int trafficClass) {
185         try {
186             channel.socket().setTrafficClass(trafficClass);
187         } catch (SocketException e) {
188             throw new RuntimeIoException(e);
189         }
190     }
191 }