src/main/decaf/net/ServerSocket.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_SERVERSOCKET_H_
#define _DECAF_NET_SERVERSOCKET_H_

#include <decaf/util/Config.h>

#include <decaf/net/InetAddress.h>
#include <decaf/net/SocketImpl.h>
#include <decaf/net/SocketImplFactory.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>

#include <string>

namespace decaf{
namespace net{

    class Socket;
    class SocketImpl;

    class DECAF_API ServerSocket {
    private:

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

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

        bool closed;
        bool bound;

        int backlog;
        int port;

    private:

        ServerSocket( const ServerSocket& );
        ServerSocket& operator= ( const ServerSocket& );

    public:

        ServerSocket();

        ServerSocket( int port );

        ServerSocket( int port, int backlog );

        ServerSocket( int port, int backlog, const InetAddress* address );

        virtual ~ServerSocket();

    protected:

        ServerSocket( SocketImpl* impl );

    public:

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

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

        virtual Socket* accept();

        virtual void close();

        virtual bool isClosed() const;

        virtual bool isBound() const;

        virtual int getReceiveBufferSize() const;

        virtual void setReceiveBufferSize( int size );

        virtual bool getReuseAddress() const;

        virtual void setReuseAddress( bool reuse );

        virtual int getSoTimeout() const;

        virtual void setSoTimeout( int timeout );

        virtual int getLocalPort() const;

        virtual std::string toString() const;

    public:

        static void setSocketImplFactory( SocketImplFactory* factory );

    protected:

        virtual void implAccept( Socket* socket );

        virtual int getDefaultBacklog();

    protected:

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

        // Binds and sets up the Listen for this Server Socket
        void setupSocketImpl( int port, int backlog, const InetAddress* ifAddress );

    };

}}

#endif // _DECAF_NET_SERVERSOCKETIMPL_H_