Socket.h

Go to the documentation of this file.

/*
 * 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;

    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:

        Socket();

        Socket( SocketImpl* impl );

        Socket( const InetAddress* address, int port );

        Socket( const InetAddress* address, int port, const InetAddress* localAddress, int localPort );

        Socket( const std::string& host, int port );

        Socket( const std::string& host, int port, const InetAddress* localAddress, int localPort );

        virtual ~Socket();

        virtual void bind( const std::string& ipaddress, int port );

        virtual void close();

        virtual void connect( const std::string& host, int port );

        virtual void connect( const std::string& host, int port, int timeout );

        bool isConnected() const {
            return connected;
        }

        bool isClosed() const {
            return closed;
        }

        bool isBound() const {
            return bound;
        }

        bool isInputShutdown() const {
            return inputShutdown;
        }

        bool isOutputShutdown() const {
            return outputShutdown;
        }

        virtual decaf::io::InputStream* getInputStream();

        virtual decaf::io::OutputStream* getOutputStream();

        int getPort() const;

        int getLocalPort() const;

        std::string getInetAddress() const;

        std::string getLocalAddress() const;

        virtual void shutdownInput();

        virtual void shutdownOutput();

        virtual int getSoLinger() const;

        virtual void setSoLinger( bool state, int timeout );

        virtual bool getKeepAlive() const;

        virtual void setKeepAlive( bool keepAlive );

        virtual int getReceiveBufferSize() const;

        virtual void setReceiveBufferSize( int size );

        virtual bool getReuseAddress() const;

        virtual void setReuseAddress( bool reuse );

        virtual int getSendBufferSize() const;

        virtual void setSendBufferSize( int size );

        virtual int getSoTimeout() const;

        virtual void setSoTimeout( int timeout );

        virtual bool getTcpNoDelay() const;

        virtual void setTcpNoDelay( bool value );

        virtual int getTrafficClass() const;

        virtual void setTrafficClass( int value );

        virtual bool getOOBInline() const;

        virtual void setOOBInline( bool value );

        virtual void sendUrgentData( int data );

        virtual std::string toString() const;

    public:

        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_*/