activemq-cpp/src/main/decaf/net/Socket.h - activemq-cpp - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF 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.
  */
 #ifndef _DECAF_NET_SOCKET_H_
 #define _DECAF_NET_SOCKET_H_

 #include <decaf/net/InetAddress.h>
 #include <decaf/net/SocketImplFactory.h>
 #include <decaf/net/SocketException.h>
 #include <decaf/io/InputStream.h>
 #include <decaf/io/OutputStream.h>
 #include <decaf/io/Closeable.h>
 #include <decaf/util/Config.h>

 #include <decaf/lang/exceptions/NullPointerException.h>
 #include <decaf/lang/exceptions/IllegalArgumentException.h>
 #include <decaf/net/UnknownHostException.h>
 #include <decaf/net/SocketTimeoutException.h>
 #include <decaf/io/IOException.h>

 namespace decaf{
 namespace net{

     class SocketImpl;
     class ServerSocket;

     /**
      *
      * @since 1.0
      */
     class DECAF_API Socket : public decaf::io::Closeable {
     protected:

         // The actual Socket that this Socket represents.
         mutable SocketImpl* impl;

     private:

         // Factory for creating sockets, if not set a Plan TCP Socket is created
         static SocketImplFactory* factory;

         mutable volatile bool created;

         bool connected;
         bool closed;
         bool bound;
         bool inputShutdown;
         bool outputShutdown;

         friend class ServerSocket;

     private:

         Socket( const Socket& );
         Socket& operator= ( const Socket& );

     public:

         /**
          * Creates an unconnected Socket using the set SocketImplFactory or if non is set
          * than the default SockImpl type is created.
          */
         Socket();

         /**
          * Creates a Socket wrapping the provided SocketImpl instance, this Socket is
          * considered unconnected.  The Socket class takes ownership of this SocketImpl
          * pointer and will delete it when the Socket class is destroyed.
          *
          * @param impl
          *      The SocketImpl instance to wrap.
          *
          * @throws NullPointerException if the passed SocketImpl is Null.
          */
         Socket( SocketImpl* impl );

         /**
          * Creates a new Socket instance and connects it to the given address and port.  If
          * there is a SocketImplFactory set then the SokcetImpl is created using the factory
          * otherwise the default Socket implementation is used.
          *
          * If the host parameter is empty then the loop back address is used.
          *
          * @param address
          *      The address to connect to.
          * @param port
          *      The port number to connect to [0...65535]
          *
          * @throws UnknownHostException if the host cannot be resolved.
          * @throws IOException if an I/O error occurs while connecting the Socket.
          * @throws NullPointerException if the InetAddress instance in NULL.
          * @throws IllegalArgumentException if the port if not in range [0...65535]
          */
         Socket( const InetAddress* address, int port );

         /**
          * Creates a new Socket instance and connects it to the given address and port.  If
          * there is a SocketImplFactory set then the SokcetImpl is created using the factory
          * otherwise the default Socket implementation is used.  The Socket will also bind
          * to the local address and port specified.
          *
          * @param address
          *      The address to connect to.
          * @param port
          *      The port number to connect to [0...65535]
          * @param localAddress
          *      The IP address on the local machine to bind to.
          * @param localPort
          *      The port on the local machine to bind to.
          *
          * @throws UnknownHostException if the host cannot be resolved.
          * @throws IOException if an I/O error occurs while connecting the Socket.
          * @throws NullPointerException if the InetAddress instance in NULL.
          * @throws IllegalArgumentException if the port if not in range [0...65535]
          */
         Socket( const InetAddress* address, int port, const InetAddress* localAddress, int localPort );

         /**
          * Creates a new Socket instance and connects it to the given host and port.  If
          * there is a SocketImplFactory set then the SokcetImpl is created using the factory
          * otherwise the default Socket implementation is used.
          *
          * If the host parameter is empty then the loop back address is used.
          *
          * @param host
          *      The host name or IP address to connect to, empty string means loopback.
          * @param port
          *      The port number to connect to [0...65535]
          *
          * @throws UnknownHostException if the host cannot be resolved.
          * @throws IOException if an I/O error occurs while connecting the Socket.
          * @throws IllegalArgumentException if the port if not in range [0...65535]
          */
         Socket( const std::string& host, int port );

         /**
          * Creates a new Socket instance and connects it to the given host and port.  If
          * there is a SocketImplFactory set then the SokcetImpl is created using the factory
          * otherwise the default Socket implementation is used.
          *
          * If the host parameter is empty then the loop back address is used.
          *
          * @param host
          *      The host name or IP address to connect to, empty string means loopback.
          * @param port
          *      The port number to connect to [0...65535]
          * @param localAddress
          *      The IP address on the local machine to bind to.
          * @param localPort
          *      The port on the local machine to bind to.
          *
          * @throws UnknownHostException if the host cannot be resolved.
          * @throws IOException if an I/O error occurs while connecting the Socket.
          * @throws IllegalArgumentException if the port if not in range [0...65535]
          */
         Socket( const std::string& host, int port, const InetAddress* localAddress, int localPort );

         virtual ~Socket();

         /**
          * Binds this Socket to the given local address and port.  If the SocketAddress
          * value is NULL then the Socket will be bound to an available local address and
          * port.
          *
          * @param ipaddress
          *      The local address and port to bind the socket to.
          * @param port
          *      The port on the local machine to bind to.
          *
          * @throws IOException if an error occurs during the bind operation.
          * @throws IllegalArgumentException if the Socket can't process the subclass of SocketAddress
          *         that has been provided.
          */
         virtual void bind( const std::string& ipaddress, int port );

         /**
          * Closes the Socket.  Once closed a Socket cannot be connected or otherwise
          * operated upon, a new Socket instance must be created.
          *
          * @throws IOException if an I/O error occurs while closing the Socket.
          */
         virtual void close();

         /**
          * Connects to the specified destination.
          *
          * @param host
          *      The host name or IP address of the remote host to connect to.
          * @param port
          *      The port on the remote host to connect to.
          *
          * @throws IOException Thrown if a failure occurred in the connect.
          * @throws IllegalArguementException if the timeout value is negative or the endpoint is invalid.
          */
         virtual void connect(const std::string& host, int port);

         /**
          * Connects to the specified destination, with a specified timeout value.  If a connection
          * to the remote host is not established within the specified timeout interval than an
          * SocketTimeoutException is thrown.  A timeout value of zero is treated as an inifinite
          * timeout.
          *
          * @param host
          *      The host name or IP address of the remote host to connect to.
          * @param port
          *      The port on the remote host to connect to.
          * @param timeout
          *      The number of Milliseconds to wait before treating the connection as failed.
          *
          * @throws IOException Thrown if a failure occurred in the connect.
          * @throws SocketTimeoutException if the timeout for connection is exceeded.
          * @throws IllegalArguementException if the timeout value is negative or the endpoint is invalid.
          */
         virtual void connect(const std::string& host, int port, int timeout);

         /**
          * Indicates whether or not this socket is connected to am end point.
          *
          * @return true if connected, false otherwise.
          */
         bool isConnected() const {
             return connected;
         }

         /**
          * @return true if the Socket has been closed.
          */
         bool isClosed() const {
             return closed;
         }

         /**
          * @return true if this Socket has been bound to a Local address.
          */
         bool isBound() const {
             return bound;
         }

         /**
          * @return true if input on this Socket has been shutdown.
          */
         bool isInputShutdown() const {
             return inputShutdown;
         }

         /**
          * @return true if output on this Socket has been shutdown.
          */
         bool isOutputShutdown() const {
             return outputShutdown;
         }

         /**
          * Gets the InputStream for this socket if its connected.  The pointer returned is the
          * property of the associated Socket and should not be deleted by the caller.
          *
          * When the returned InputStream is performing a blocking operation and the underlying
          * connection is closed or otherwise broker the read calls will normally throw an exception
          * to indicate the failure.
          *
          * Closing the InputStream will also close the underlying Socket.
          *
          * @return The InputStream for this socket.
          *
          * @throws IOException if an error occurs during creation of the InputStream, also if the
          *         Socket is not connected or the input has been shutdown previously.
          */
         virtual decaf::io::InputStream* getInputStream();

         /**
          * Gets the OutputStream for this socket if it is connected.  The pointer returned is the
          * property of the Socket instance and should not be deleted by the caller.
          *
          * Closing the returned Socket will also close the underlying Socket.
          *
          * @return the OutputStream for this socket.
          *
          * @throws IOException if an error occurs during the creation of this OutputStream, or
          *         if the Socket is closed or the output has been shutdown previously.
          */
         virtual decaf::io::OutputStream* getOutputStream();

         /**
          * Gets the on the remote host this Socket is connected to.
          *
          * @return the port on the remote host the socket is connected to, or 0 if not connected.
          */
         int getPort() const;

         /**
          * Gets the local port the socket is bound to.
          *
          * @return the local port the socket was bound to, or -1 if the socket is not bound.
          */
         int getLocalPort() const;

         /**
          * Returns the address to which the socket is connected.
          *
          * @return the remote IP address to which this socket is connected, or null if the socket is not connected.
          */
         std::string getInetAddress() const;

         /**
          * Gets the local address to which the socket is bound.
          *
          * @return the local address to which the socket is bound or InetAddress.anyLocalAddress() if the socket is not bound yet.
          */
         std::string getLocalAddress() const;

         /**
          * Shuts down the InputStream for this socket essentially marking it as EOF.  The stream
          * returns EOF for any calls to read after this method has been called.
          *
          * @throws IOException if an I/O error occurs while performing this operation.
          */
         virtual void shutdownInput();

         /**
          * Shuts down the OutputStream for this socket, any data already written to the socket will
          * be sent, any further calls to OuputStream::write will throw an IOException.
          *
          * @throws IOException if an I/O error occurs while performing this operation.
          */
         virtual void shutdownOutput();

         /**
          * Gets the linger time for the socket, SO_LINGER.  A return value of -1 indicates that
          * the option is disabled.
          *
          * @return The linger time in seconds.
          *
          * @throws SocketException if the operation fails.
          */
         virtual int getSoLinger() const;

         /**
          * Sets the linger time (SO_LINGER) using a specified time value, this limits of this
          * value are platform specific.
          *
          * @param state
          *      The state of SO_LINGER, true is on.
          * @param timeout
          *      The linger time in seconds, must be non-negative.
          *
          * @throws SocketException if the operation fails.
          * @throws IllegalArgumentException if state is true and timeout is negative.
          */
         virtual void setSoLinger(bool state, int timeout);

         /**
          * Gets the keep alive flag for this socket, SO_KEEPALIVE.
          *
          * @return true if keep alive is enabled for this socket.
          *
          * @throws SocketException if the operation fails.
          */
         virtual bool getKeepAlive() const;

         /**
          * Enables/disables the keep alive flag for this socket, SO_KEEPALIVE.
          *
          * @param keepAlive
          *      If true, enables the flag.
          *
          * @throws SocketException if the operation fails.
          */
         virtual void setKeepAlive(bool keepAlive);

         /**
          * Gets the receive buffer size for this socket, SO_RCVBUF.  This is the buffer used
          * by the underlying platform socket to buffer received data.
          *
          * @return the receive buffer size in bytes.
          *
          * @throws SocketException if the operation fails.
          */
         virtual int getReceiveBufferSize() const;

         /**
          * Sets the receive buffer size for this socket, SO_RCVBUF.
          *
          * @param size
          *      Number of bytes to set the receive buffer to.
          *
          * @throws SocketException if the operation fails.
          * @throws IllegalArgumentException if the value is zero or negative.
          */
         virtual void setReceiveBufferSize(int size);

         /**
          * Gets the reuse address flag, SO_REUSEADDR.
          *
          * @return True if the address can be reused.
          *
          * @throws SocketException if the operation fails.
          */
         virtual bool getReuseAddress() const;

         /**
          * Sets the reuse address flag, SO_REUSEADDR.
          *
          * @param reuse
          *      If true, sets the flag.
          *
          * @throws SocketException if the operation fails.
          */
         virtual void setReuseAddress(bool reuse);

         /**
          * Gets the send buffer size for this socket, SO_SNDBUF, this value is used by the platform
          * socket to buffer data written to the socket.
          *
          * @return the size in bytes of the send buffer.
          *
          * @throws SocketException if the operation fails.
          */
         virtual int getSendBufferSize() const;

         /**
          * Gets the send buffer size for this socket, SO_SNDBUF, this value is used by the platform
          * socket to buffer data written to the socket.
          *
          * @param size
          *      The number of bytes to set the send buffer to, must be larger than zero.
          *
          * @throws SocketException if the operation fails.
          * @throws IllegalArgumentException if the value is zero or negative.
          */
         virtual void setSendBufferSize(int size);

         /**
          * Gets the timeout for socket operations, SO_TIMEOUT.
          *
          * @return The timeout in milliseconds for socket operations.
          *
          * @throws SocketException Thrown if unable to retrieve the information.
          */
         virtual int getSoTimeout() const;

         /**
          * Sets the timeout for socket operations, SO_TIMEOUT.  A value of zero indicates that timeout
          * is infinite for operations on this socket.
          *
          * @param timeout
          *      The timeout in milliseconds for socket operations.
          *
          * @throws SocketException Thrown if unable to set the information.
          * @throws IllegalArgumentException if the timeout value is negative.
          */
         virtual void setSoTimeout(int timeout);

         /**
          * Gets the Status of the TCP_NODELAY setting for this socket.
          *
          * @return true if TCP_NODELAY is enabled for the socket.
          *
          * @throws SocketException Thrown if unable to set the information.
          */
         virtual bool getTcpNoDelay() const;

         /**
          * Sets the Status of the TCP_NODELAY param for this socket., this setting is used
          * to disable or enable Nagle's algorithm on the Socket.
          *
          * @param value
          *      The setting for the socket's TCP_NODELAY option, true to enable.
          *
          * @throws SocketException Thrown if unable to set the information.
          */
         virtual void setTcpNoDelay(bool value);

         /**
          * Gets the Traffic Class setting for this Socket, sometimes referred to as Type of
          * Service setting.  This setting is dependent on the underlying network implementation
          * for the platform this Socket runs on and is not guaranteed to have any effect.
          *
          * Refer to your platforms network documentation regarding support for this setting.
          *
          * @return the bitset result of querying the traffic class setting.
          *
          * @throws SocketException if an error is encountered while performing this operation.
          */
         virtual int getTrafficClass() const;

         /**
          * Gets the Traffic Class setting for this Socket, sometimes referred to as Type of
          * Service setting.  This setting is dependent on the underlying network implementation
          * for the platform this Socket runs on and is not guaranteed to have any effect.
          *
          * Refer to your platforms network documentation regarding support for this setting.
          *
          * @param value
          *      The integer value representing the traffic class setting bitset.
          *
          * @throws SocketException if an error is encountered while performing this operation.
          * @throws IllegalArgumentException if the value is not in the range [0..255].
          */
         virtual void setTrafficClass(int value);

         /**
          * Gets the value of the OOBINLINE for this socket.
          *
          * @return true if OOBINLINE is enabled, false otherwise.
          *
          * @throws SocketException if an error is encountered while performing this operation.
          */
         virtual bool getOOBInline() const;

         /**
          * Sets the value of the OOBINLINE for this socket, by default this option is disabled.  If
          * enabled the urgent data is read inline on the Socket's InputStream, no notification is give.
          *
          * @return true if OOBINLINE is enabled, false otherwise.
          *
          * @throws SocketException if an error is encountered while performing this operation.
          */
         virtual void setOOBInline(bool value);

         /**
          * Sends on byte of urgent data to the Socket.
          *
          * @param data
          *      The value to write as urgent data, only the lower eight bits are sent.
          *
          * @throws IOException if an I/O error occurs while performing this operation.
          */
         virtual void sendUrgentData(int data);

         /**
          * @return a string representing this Socket.
          */
         virtual std::string toString() const;

     public:

         /**
          * Sets the instance of a SocketImplFactory that the Socket class should use when new
          * instances of this class are created.  This method is only allowed to be used once
          * during the lifetime of the application.
          *
          * @param factory
          *      The instance of a SocketImplFactory to use when new Socket objects are created.
          *
          * @throws IOException if an I/O error occurs while performing this operation.
          * @throws SocketException if this method has already been called with a valid factory.
          */
         static void setSocketImplFactory( SocketImplFactory* factory );

     protected:

         // Flags the Socket instance as created, bound and connected when its connected
         // via a ServerSocket accept call.
         void accepted();

         // Sets up a connected socket for the constructors that take connection arguments.
         void initSocketImpl( const std::string& address, int port, const InetAddress* localAddress, int localPort );

         // Check for already closed and throw an error if so.
         void checkClosed() const;

         // Create but don't connect the underlying OS Socket instance, if not already created.
         void ensureCreated() const;

     };

 }}

 #endif /*_DECAF_NET_SOCKET_H_*/
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF 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.
	*/
	#ifndef _DECAF_NET_SOCKET_H_
	#define _DECAF_NET_SOCKET_H_

	#include <decaf/net/InetAddress.h>
	#include <decaf/net/SocketImplFactory.h>
	#include <decaf/net/SocketException.h>
	#include <decaf/io/InputStream.h>
	#include <decaf/io/OutputStream.h>
	#include <decaf/io/Closeable.h>
	#include <decaf/util/Config.h>

	#include <decaf/lang/exceptions/NullPointerException.h>
	#include <decaf/lang/exceptions/IllegalArgumentException.h>
	#include <decaf/net/UnknownHostException.h>
	#include <decaf/net/SocketTimeoutException.h>
	#include <decaf/io/IOException.h>

	namespace decaf{
	namespace net{

	class SocketImpl;
	class ServerSocket;

	/**
	*
	* @since 1.0
	*/
	class DECAF_API Socket : public decaf::io::Closeable {
	protected:

	// The actual Socket that this Socket represents.
	mutable SocketImpl* impl;

	private:

	// Factory for creating sockets, if not set a Plan TCP Socket is created
	static SocketImplFactory* factory;

	mutable volatile bool created;

	bool connected;
	bool closed;
	bool bound;
	bool inputShutdown;
	bool outputShutdown;

	friend class ServerSocket;

	private:

	Socket( const Socket& );
	Socket& operator= ( const Socket& );

	public:

	/**
	* Creates an unconnected Socket using the set SocketImplFactory or if non is set
	* than the default SockImpl type is created.
	*/
	Socket();

	/**
	* Creates a Socket wrapping the provided SocketImpl instance, this Socket is
	* considered unconnected. The Socket class takes ownership of this SocketImpl
	* pointer and will delete it when the Socket class is destroyed.
	*
	* @param impl
	* The SocketImpl instance to wrap.
	*
	* @throws NullPointerException if the passed SocketImpl is Null.
	*/
	Socket( SocketImpl* impl );

	/**
	* Creates a new Socket instance and connects it to the given address and port. If
	* there is a SocketImplFactory set then the SokcetImpl is created using the factory
	* otherwise the default Socket implementation is used.
	*
	* If the host parameter is empty then the loop back address is used.
	*
	* @param address
	* The address to connect to.
	* @param port
	* The port number to connect to [0...65535]
	*
	* @throws UnknownHostException if the host cannot be resolved.
	* @throws IOException if an I/O error occurs while connecting the Socket.
	* @throws NullPointerException if the InetAddress instance in NULL.
	* @throws IllegalArgumentException if the port if not in range [0...65535]
	*/
	Socket( const InetAddress* address, int port );

	/**
	* Creates a new Socket instance and connects it to the given address and port. If
	* there is a SocketImplFactory set then the SokcetImpl is created using the factory
	* otherwise the default Socket implementation is used. The Socket will also bind
	* to the local address and port specified.
	*
	* @param address
	* The address to connect to.
	* @param port
	* The port number to connect to [0...65535]
	* @param localAddress
	* The IP address on the local machine to bind to.
	* @param localPort
	* The port on the local machine to bind to.
	*
	* @throws UnknownHostException if the host cannot be resolved.
	* @throws IOException if an I/O error occurs while connecting the Socket.
	* @throws NullPointerException if the InetAddress instance in NULL.
	* @throws IllegalArgumentException if the port if not in range [0...65535]
	*/
	Socket( const InetAddress* address, int port, const InetAddress* localAddress, int localPort );

	/**
	* Creates a new Socket instance and connects it to the given host and port. If
	* there is a SocketImplFactory set then the SokcetImpl is created using the factory
	* otherwise the default Socket implementation is used.
	*
	* If the host parameter is empty then the loop back address is used.
	*
	* @param host
	* The host name or IP address to connect to, empty string means loopback.
	* @param port
	* The port number to connect to [0...65535]
	*
	* @throws UnknownHostException if the host cannot be resolved.
	* @throws IOException if an I/O error occurs while connecting the Socket.
	* @throws IllegalArgumentException if the port if not in range [0...65535]
	*/
	Socket( const std::string& host, int port );

	/**
	* Creates a new Socket instance and connects it to the given host and port. If
	* there is a SocketImplFactory set then the SokcetImpl is created using the factory
	* otherwise the default Socket implementation is used.
	*
	* If the host parameter is empty then the loop back address is used.
	*
	* @param host
	* The host name or IP address to connect to, empty string means loopback.
	* @param port
	* The port number to connect to [0...65535]
	* @param localAddress
	* The IP address on the local machine to bind to.
	* @param localPort
	* The port on the local machine to bind to.
	*
	* @throws UnknownHostException if the host cannot be resolved.
	* @throws IOException if an I/O error occurs while connecting the Socket.
	* @throws IllegalArgumentException if the port if not in range [0...65535]
	*/
	Socket( const std::string& host, int port, const InetAddress* localAddress, int localPort );

	virtual ~Socket();

	/**
	* Binds this Socket to the given local address and port. If the SocketAddress
	* value is NULL then the Socket will be bound to an available local address and
	* port.
	*
	* @param ipaddress
	* The local address and port to bind the socket to.
	* @param port
	* The port on the local machine to bind to.
	*
	* @throws IOException if an error occurs during the bind operation.
	* @throws IllegalArgumentException if the Socket can't process the subclass of SocketAddress
	* that has been provided.
	*/
	virtual void bind( const std::string& ipaddress, int port );

	/**
	* Closes the Socket. Once closed a Socket cannot be connected or otherwise
	* operated upon, a new Socket instance must be created.
	*
	* @throws IOException if an I/O error occurs while closing the Socket.
	*/
	virtual void close();

	/**
	* Connects to the specified destination.
	*
	* @param host
	* The host name or IP address of the remote host to connect to.
	* @param port
	* The port on the remote host to connect to.
	*
	* @throws IOException Thrown if a failure occurred in the connect.
	* @throws IllegalArguementException if the timeout value is negative or the endpoint is invalid.
	*/
	virtual void connect(const std::string& host, int port);

	/**
	* Connects to the specified destination, with a specified timeout value. If a connection
	* to the remote host is not established within the specified timeout interval than an
	* SocketTimeoutException is thrown. A timeout value of zero is treated as an inifinite
	* timeout.
	*
	* @param host
	* The host name or IP address of the remote host to connect to.
	* @param port
	* The port on the remote host to connect to.
	* @param timeout
	* The number of Milliseconds to wait before treating the connection as failed.
	*
	* @throws IOException Thrown if a failure occurred in the connect.
	* @throws SocketTimeoutException if the timeout for connection is exceeded.
	* @throws IllegalArguementException if the timeout value is negative or the endpoint is invalid.
	*/
	virtual void connect(const std::string& host, int port, int timeout);

	/**
	* Indicates whether or not this socket is connected to am end point.
	*
	* @return true if connected, false otherwise.
	*/
	bool isConnected() const {
	return connected;
	}

	/**
	* @return true if the Socket has been closed.
	*/
	bool isClosed() const {
	return closed;
	}

	/**
	* @return true if this Socket has been bound to a Local address.
	*/
	bool isBound() const {
	return bound;
	}

	/**
	* @return true if input on this Socket has been shutdown.
	*/
	bool isInputShutdown() const {
	return inputShutdown;
	}

	/**
	* @return true if output on this Socket has been shutdown.
	*/
	bool isOutputShutdown() const {
	return outputShutdown;
	}

	/**
	* Gets the InputStream for this socket if its connected. The pointer returned is the
	* property of the associated Socket and should not be deleted by the caller.
	*
	* When the returned InputStream is performing a blocking operation and the underlying
	* connection is closed or otherwise broker the read calls will normally throw an exception
	* to indicate the failure.
	*
	* Closing the InputStream will also close the underlying Socket.
	*
	* @return The InputStream for this socket.
	*
	* @throws IOException if an error occurs during creation of the InputStream, also if the
	* Socket is not connected or the input has been shutdown previously.
	*/
	virtual decaf::io::InputStream* getInputStream();

	/**
	* Gets the OutputStream for this socket if it is connected. The pointer returned is the
	* property of the Socket instance and should not be deleted by the caller.
	*
	* Closing the returned Socket will also close the underlying Socket.
	*
	* @return the OutputStream for this socket.
	*
	* @throws IOException if an error occurs during the creation of this OutputStream, or
	* if the Socket is closed or the output has been shutdown previously.
	*/
	virtual decaf::io::OutputStream* getOutputStream();

	/**
	* Gets the on the remote host this Socket is connected to.
	*
	* @return the port on the remote host the socket is connected to, or 0 if not connected.
	*/
	int getPort() const;

	/**
	* Gets the local port the socket is bound to.
	*
	* @return the local port the socket was bound to, or -1 if the socket is not bound.
	*/
	int getLocalPort() const;

	/**
	* Returns the address to which the socket is connected.
	*
	* @return the remote IP address to which this socket is connected, or null if the socket is not connected.
	*/
	std::string getInetAddress() const;

	/**
	* Gets the local address to which the socket is bound.
	*
	* @return the local address to which the socket is bound or InetAddress.anyLocalAddress() if the socket is not bound yet.
	*/
	std::string getLocalAddress() const;

	/**
	* Shuts down the InputStream for this socket essentially marking it as EOF. The stream
	* returns EOF for any calls to read after this method has been called.
	*
	* @throws IOException if an I/O error occurs while performing this operation.
	*/
	virtual void shutdownInput();

	/**
	* Shuts down the OutputStream for this socket, any data already written to the socket will
	* be sent, any further calls to OuputStream::write will throw an IOException.
	*
	* @throws IOException if an I/O error occurs while performing this operation.
	*/
	virtual void shutdownOutput();

	/**
	* Gets the linger time for the socket, SO_LINGER. A return value of -1 indicates that
	* the option is disabled.
	*
	* @return The linger time in seconds.
	*
	* @throws SocketException if the operation fails.
	*/
	virtual int getSoLinger() const;

	/**
	* Sets the linger time (SO_LINGER) using a specified time value, this limits of this
	* value are platform specific.
	*
	* @param state
	* The state of SO_LINGER, true is on.
	* @param timeout
	* The linger time in seconds, must be non-negative.
	*
	* @throws SocketException if the operation fails.
	* @throws IllegalArgumentException if state is true and timeout is negative.
	*/
	virtual void setSoLinger(bool state, int timeout);

	/**
	* Gets the keep alive flag for this socket, SO_KEEPALIVE.
	*
	* @return true if keep alive is enabled for this socket.
	*
	* @throws SocketException if the operation fails.
	*/
	virtual bool getKeepAlive() const;

	/**
	* Enables/disables the keep alive flag for this socket, SO_KEEPALIVE.
	*
	* @param keepAlive
	* If true, enables the flag.
	*
	* @throws SocketException if the operation fails.
	*/
	virtual void setKeepAlive(bool keepAlive);

	/**
	* Gets the receive buffer size for this socket, SO_RCVBUF. This is the buffer used
	* by the underlying platform socket to buffer received data.
	*
	* @return the receive buffer size in bytes.
	*
	* @throws SocketException if the operation fails.
	*/
	virtual int getReceiveBufferSize() const;

	/**
	* Sets the receive buffer size for this socket, SO_RCVBUF.
	*
	* @param size
	* Number of bytes to set the receive buffer to.
	*
	* @throws SocketException if the operation fails.
	* @throws IllegalArgumentException if the value is zero or negative.
	*/
	virtual void setReceiveBufferSize(int size);

	/**
	* Gets the reuse address flag, SO_REUSEADDR.
	*
	* @return True if the address can be reused.
	*
	* @throws SocketException if the operation fails.
	*/
	virtual bool getReuseAddress() const;

	/**
	* Sets the reuse address flag, SO_REUSEADDR.
	*
	* @param reuse
	* If true, sets the flag.
	*
	* @throws SocketException if the operation fails.
	*/
	virtual void setReuseAddress(bool reuse);

	/**
	* Gets the send buffer size for this socket, SO_SNDBUF, this value is used by the platform
	* socket to buffer data written to the socket.
	*
	* @return the size in bytes of the send buffer.
	*
	* @throws SocketException if the operation fails.
	*/
	virtual int getSendBufferSize() const;

	/**
	* Gets the send buffer size for this socket, SO_SNDBUF, this value is used by the platform
	* socket to buffer data written to the socket.
	*
	* @param size
	* The number of bytes to set the send buffer to, must be larger than zero.
	*
	* @throws SocketException if the operation fails.
	* @throws IllegalArgumentException if the value is zero or negative.
	*/
	virtual void setSendBufferSize(int size);

	/**
	* Gets the timeout for socket operations, SO_TIMEOUT.
	*
	* @return The timeout in milliseconds for socket operations.
	*
	* @throws SocketException Thrown if unable to retrieve the information.
	*/
	virtual int getSoTimeout() const;

	/**
	* Sets the timeout for socket operations, SO_TIMEOUT. A value of zero indicates that timeout
	* is infinite for operations on this socket.
	*
	* @param timeout
	* The timeout in milliseconds for socket operations.
	*
	* @throws SocketException Thrown if unable to set the information.
	* @throws IllegalArgumentException if the timeout value is negative.
	*/
	virtual void setSoTimeout(int timeout);

	/**
	* Gets the Status of the TCP_NODELAY setting for this socket.
	*
	* @return true if TCP_NODELAY is enabled for the socket.
	*
	* @throws SocketException Thrown if unable to set the information.
	*/
	virtual bool getTcpNoDelay() const;

	/**
	* Sets the Status of the TCP_NODELAY param for this socket., this setting is used
	* to disable or enable Nagle's algorithm on the Socket.
	*
	* @param value
	* The setting for the socket's TCP_NODELAY option, true to enable.
	*
	* @throws SocketException Thrown if unable to set the information.
	*/
	virtual void setTcpNoDelay(bool value);

	/**
	* Gets the Traffic Class setting for this Socket, sometimes referred to as Type of
	* Service setting. This setting is dependent on the underlying network implementation
	* for the platform this Socket runs on and is not guaranteed to have any effect.
	*
	* Refer to your platforms network documentation regarding support for this setting.
	*
	* @return the bitset result of querying the traffic class setting.
	*
	* @throws SocketException if an error is encountered while performing this operation.
	*/
	virtual int getTrafficClass() const;

	/**
	* Gets the Traffic Class setting for this Socket, sometimes referred to as Type of
	* Service setting. This setting is dependent on the underlying network implementation
	* for the platform this Socket runs on and is not guaranteed to have any effect.
	*
	* Refer to your platforms network documentation regarding support for this setting.
	*
	* @param value
	* The integer value representing the traffic class setting bitset.
	*
	* @throws SocketException if an error is encountered while performing this operation.
	* @throws IllegalArgumentException if the value is not in the range [0..255].
	*/
	virtual void setTrafficClass(int value);

	/**
	* Gets the value of the OOBINLINE for this socket.
	*
	* @return true if OOBINLINE is enabled, false otherwise.
	*
	* @throws SocketException if an error is encountered while performing this operation.
	*/
	virtual bool getOOBInline() const;

	/**
	* Sets the value of the OOBINLINE for this socket, by default this option is disabled. If
	* enabled the urgent data is read inline on the Socket's InputStream, no notification is give.
	*
	* @return true if OOBINLINE is enabled, false otherwise.
	*
	* @throws SocketException if an error is encountered while performing this operation.
	*/
	virtual void setOOBInline(bool value);

	/**
	* Sends on byte of urgent data to the Socket.
	*
	* @param data
	* The value to write as urgent data, only the lower eight bits are sent.
	*
	* @throws IOException if an I/O error occurs while performing this operation.
	*/
	virtual void sendUrgentData(int data);

	/**
	* @return a string representing this Socket.
	*/
	virtual std::string toString() const;

	public:

	/**
	* Sets the instance of a SocketImplFactory that the Socket class should use when new
	* instances of this class are created. This method is only allowed to be used once
	* during the lifetime of the application.
	*
	* @param factory
	* The instance of a SocketImplFactory to use when new Socket objects are created.
	*
	* @throws IOException if an I/O error occurs while performing this operation.
	* @throws SocketException if this method has already been called with a valid factory.
	*/
	static void setSocketImplFactory( SocketImplFactory* factory );

	protected:

	// Flags the Socket instance as created, bound and connected when its connected
	// via a ServerSocket accept call.
	void accepted();

	// Sets up a connected socket for the constructors that take connection arguments.
	void initSocketImpl( const std::string& address, int port, const InetAddress* localAddress, int localPort );

	// Check for already closed and throw an error if so.
	void checkClosed() const;

	// Create but don't connect the underlying OS Socket instance, if not already created.
	void ensureCreated() const;

	};

	}}

	#endif /_DECAF_NET_SOCKET_H_/