Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.DatagramSocketClient |
0% |
0% |

1 |  |
     /*
2 |  |
      * Copyright 2001-2005 The Apache Software Foundation
3 |  |
      *
4 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
5 |  |
      * you may not use this file except in compliance with the License.
6 |  |
      * 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,
12 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  |
      * See the License for the specific language governing permissions and
14 |  |
      * limitations under the License.
15 |  |
      */
16 |  |
     package org.apache.commons.net;
17 |  |
18 |  |
     import java.net.DatagramSocket;
19 |  |
     import java.net.InetAddress;
20 |  |
     import java.net.SocketException;
21 |  |
22 |  |
     /***
23 |  |
      * The DatagramSocketClient provides the basic operations that are required
24 |  |
      * of client objects accessing datagram sockets.  It is meant to be
25 |  |
      * subclassed to avoid having to rewrite the same code over and over again
26 |  |
      * to open a socket, close a socket, set timeouts, etc.  Of special note
27 |  |
      * is the {@link #setDatagramSocketFactory  setDatagramSocketFactory }
28 |  |
      * method, which allows you to control the type of DatagramSocket the
29 |  |
      * DatagramSocketClient creates for network communications.  This is
30 |  |
      * especially useful for adding things like proxy support as well as better
31 |  |
      * support for applets.  For
32 |  |
      * example, you could create a
33 |  |
      * {@link org.apache.commons.net.DatagramSocketFactory}
34 |  |
      *  that
35 |  |
      * requests browser security capabilities before creating a socket.
36 |  |
      * All classes derived from DatagramSocketClient should use the
37 |  |
      * {@link #_socketFactory_  _socketFactory_ } member variable to
38 |  |
      * create DatagramSocket instances rather than instantiating
39 |  |
      * them by directly invoking a constructor.  By honoring this contract
40 |  |
      * you guarantee that a user will always be able to provide his own
41 |  |
      * Socket implementations by substituting his own SocketFactory.
42 |  |
      * <p>
43 |  |
      * <p>
44 |  |
      * @author Daniel F. Savarese
45 |  |
      * @see DatagramSocketFactory
46 |  |
      ***/
47 |  |
48 |  |
     public abstract class DatagramSocketClient
49 |  |
     {
50 |  |
         /***
51 |  |
          * The default DatagramSocketFactory shared by all DatagramSocketClient
52 |  |
          * instances.
53 |  |
          ***/
54 | 0 |
         private static final DatagramSocketFactory __DEFAULT_SOCKET_FACTORY =
55 |  |
             new DefaultDatagramSocketFactory();
56 |  |
57 |  |
         /*** The timeout to use after opening a socket. ***/
58 |  |
         protected int _timeout_;
59 |  |
60 |  |
         /*** The datagram socket used for the connection. ***/
61 |  |
         protected DatagramSocket _socket_;
62 |  |
63 |  |
         /***
64 |  |
          * A status variable indicating if the client's socket is currently open.
65 |  |
          ***/
66 |  |
         protected boolean _isOpen_;
67 |  |
68 |  |
         /*** The datagram socket's DatagramSocketFactory. ***/
69 |  |
         protected DatagramSocketFactory _socketFactory_;
70 |  |
71 |  |
         /***
72 |  |
          * Default constructor for DatagramSocketClient.  Initializes
73 |  |
          * _socket_ to null, _timeout_ to 0, and _isOpen_ to false.
74 |  |
          ***/
75 |  |
         public DatagramSocketClient()
76 | 0 |
         {
77 | 0 |
             _socket_ = null;
78 | 0 |
             _timeout_ = 0;
79 | 0 |
             _isOpen_ = false;
80 | 0 |
             _socketFactory_ = __DEFAULT_SOCKET_FACTORY;
81 | 0 |
         }
82 |  |
83 |  |
84 |  |
         /***
85 |  |
          * Opens a DatagramSocket on the local host at the first available port.
86 |  |
          * Also sets the timeout on the socket to the default timeout set
87 |  |
          * by {@link #setDefaultTimeout  setDefaultTimeout() }.
88 |  |
          * <p>
89 |  |
          * _isOpen_ is set to true after calling this method and _socket_
90 |  |
          * is set to the newly opened socket.
91 |  |
          * <p>
92 |  |
          * @exception SocketException If the socket could not be opened or the
93 |  |
          *   timeout could not be set.
94 |  |
          ***/
95 |  |
         public void open() throws SocketException
96 |  |
         {
97 | 0 |
             _socket_ = _socketFactory_.createDatagramSocket();
98 | 0 |
             _socket_.setSoTimeout(_timeout_);
99 | 0 |
             _isOpen_ = true;
100 | 0 |
         }
101 |  |
102 |  |
103 |  |
         /***
104 |  |
          * Opens a DatagramSocket on the local host at a specified port.
105 |  |
          * Also sets the timeout on the socket to the default timeout set
106 |  |
          * by {@link #setDefaultTimeout  setDefaultTimeout() }.
107 |  |
          * <p>
108 |  |
          * _isOpen_ is set to true after calling this method and _socket_
109 |  |
          * is set to the newly opened socket.
110 |  |
          * <p>
111 |  |
          * @param port The port to use for the socket.
112 |  |
          * @exception SocketException If the socket could not be opened or the
113 |  |
          *   timeout could not be set.
114 |  |
          ***/
115 |  |
         public void open(int port) throws SocketException
116 |  |
         {
117 | 0 |
             _socket_ = _socketFactory_.createDatagramSocket(port);
118 | 0 |
             _socket_.setSoTimeout(_timeout_);
119 | 0 |
             _isOpen_ = true;
120 | 0 |
         }
121 |  |
122 |  |
123 |  |
         /***
124 |  |
          * Opens a DatagramSocket at the specified address on the local host
125 |  |
          * at a specified port.
126 |  |
          * Also sets the timeout on the socket to the default timeout set
127 |  |
          * by {@link #setDefaultTimeout  setDefaultTimeout() }.
128 |  |
          * <p>
129 |  |
          * _isOpen_ is set to true after calling this method and _socket_
130 |  |
          * is set to the newly opened socket.
131 |  |
          * <p>
132 |  |
          * @param port The port to use for the socket.
133 |  |
          * @param laddr  The local address to use.
134 |  |
          * @exception SocketException If the socket could not be opened or the
135 |  |
          *   timeout could not be set.
136 |  |
          ***/
137 |  |
         public void open(int port, InetAddress laddr) throws SocketException
138 |  |
         {
139 | 0 |
             _socket_ = _socketFactory_.createDatagramSocket(port, laddr);
140 | 0 |
             _socket_.setSoTimeout(_timeout_);
141 | 0 |
             _isOpen_ = true;
142 | 0 |
         }
143 |  |
144 |  |
145 |  |
146 |  |
         /***
147 |  |
          * Closes the DatagramSocket used for the connection.
148 |  |
          * You should call this method after you've finished using the class
149 |  |
          * instance and also before you call {@link #open open() }
150 |  |
          * again.   _isOpen_ is set to false and  _socket_ is set to null.
151 |  |
          * If you call this method when the client socket is not open,
152 |  |
          * a NullPointerException is thrown.
153 |  |
          ***/
154 |  |
         public void close()
155 |  |
         {
156 | 0 |
             _socket_.close();
157 | 0 |
             _socket_ = null;
158 | 0 |
             _isOpen_ = false;
159 | 0 |
         }
160 |  |
161 |  |
162 |  |
         /***
163 |  |
          * Returns true if the client has a currently open socket.
164 |  |
          * <p>
165 |  |
          * @return True if the client has a curerntly open socket, false otherwise.
166 |  |
          ***/
167 |  |
         public boolean isOpen()
168 |  |
         {
169 | 0 |
             return _isOpen_;
170 |  |
         }
171 |  |
172 |  |
173 |  |
         /***
174 |  |
          * Set the default timeout in milliseconds to use when opening a socket.
175 |  |
          * After a call to open, the timeout for the socket is set using this value.
176 |  |
          * This method should be used prior to a call to {@link #open open()}
177 |  |
          * and should not be confused with {@link #setSoTimeout setSoTimeout()}
178 |  |
          * which operates on the currently open socket.  _timeout_ contains
179 |  |
          * the new timeout value.
180 |  |
          * <p>
181 |  |
          * @param timeout  The timeout in milliseconds to use for the datagram socket
182 |  |
          *                 connection.
183 |  |
          ***/
184 |  |
         public void setDefaultTimeout(int timeout)
185 |  |
         {
186 | 0 |
             _timeout_ = timeout;
187 | 0 |
         }
188 |  |
189 |  |
190 |  |
         /***
191 |  |
          * Returns the default timeout in milliseconds that is used when
192 |  |
          * opening a socket.
193 |  |
          * <p>
194 |  |
          * @return The default timeout in milliseconds that is used when
195 |  |
          *         opening a socket.
196 |  |
          ***/
197 |  |
         public int getDefaultTimeout()
198 |  |
         {
199 | 0 |
             return _timeout_;
200 |  |
         }
201 |  |
202 |  |
203 |  |
         /***
204 |  |
          * Set the timeout in milliseconds of a currently open connection.
205 |  |
          * Only call this method after a connection has been opened
206 |  |
          * by {@link #open open()}.
207 |  |
          * <p>
208 |  |
          * @param timeout  The timeout in milliseconds to use for the currently
209 |  |
          *                 open datagram socket connection.
210 |  |
          ***/
211 |  |
         public void setSoTimeout(int timeout) throws SocketException
212 |  |
         {
213 | 0 |
             _socket_.setSoTimeout(timeout);
214 | 0 |
         }
215 |  |
216 |  |
217 |  |
         /***
218 |  |
          * Returns the timeout in milliseconds of the currently opened socket.
219 |  |
          * If you call this method when the client socket is not open,
220 |  |
          * a NullPointerException is thrown.
221 |  |
          * <p>
222 |  |
          * @return The timeout in milliseconds of the currently opened socket.
223 |  |
          ***/
224 |  |
         public int getSoTimeout() throws SocketException
225 |  |
         {
226 | 0 |
             return _socket_.getSoTimeout();
227 |  |
         }
228 |  |
229 |  |
230 |  |
         /***
231 |  |
          * Returns the port number of the open socket on the local host used
232 |  |
          * for the connection.  If you call this method when the client socket
233 |  |
          * is not open, a NullPointerException is thrown.
234 |  |
          * <p>
235 |  |
          * @return The port number of the open socket on the local host used
236 |  |
          *         for the connection.
237 |  |
          ***/
238 |  |
         public int getLocalPort()
239 |  |
         {
240 | 0 |
             return _socket_.getLocalPort();
241 |  |
         }
242 |  |
243 |  |
244 |  |
         /***
245 |  |
          * Returns the local address to which the client's socket is bound.
246 |  |
          * If you call this method when the client socket is not open, a
247 |  |
          * NullPointerException is thrown.
248 |  |
          * <p>
249 |  |
          * @return The local address to which the client's socket is bound.
250 |  |
          ***/
251 |  |
         public InetAddress getLocalAddress()
252 |  |
         {
253 | 0 |
             return _socket_.getLocalAddress();
254 |  |
         }
255 |  |
256 |  |
257 |  |
         /***
258 |  |
          * Sets the DatagramSocketFactory used by the DatagramSocketClient
259 |  |
          * to open DatagramSockets.  If the factory value is null, then a default
260 |  |
          * factory is used (only do this to reset the factory after having
261 |  |
          * previously altered it).
262 |  |
          * <p>
263 |  |
          * @param factory  The new DatagramSocketFactory the DatagramSocketClient
264 |  |
          * should use.
265 |  |
          ***/
266 |  |
         public void setDatagramSocketFactory(DatagramSocketFactory factory)
267 |  |
         {
268 | 0 |
             if (factory == null)
269 | 0 |
                 _socketFactory_ = __DEFAULT_SOCKET_FACTORY;
270 |  |
             else
271 | 0 |
                 _socketFactory_ = factory;
272 | 0 |
         }
273 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.