Overview | Package | Class | Tree | Deprecated | Index | Help
Qt Jambi Home |
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.trolltech.qt.network
Class QTcpServer

    java.lang.Object
      com.trolltech.qt.QSignalEmitter
          com.trolltech.qt.QtJambiObject
              com.trolltech.qt.core.QObject
                  com.trolltech.qt.network.QTcpServer

All Implemented Interfaces:
  QtJambiInterface

    public class QTcpServer

extends QObject

The `QTcpServer` class provides a TCP-based server.

This class makes it possible to accept incoming TCP connections. You can specify the port or have `QTcpServer` pick one automatically. You can listen on a specific address or on all the machine's addresses.

Call listen() to have the server listen for incoming connections. The `newConnection` signal is then emitted each time a client connects to the server.

Call `nextPendingConnection` to accept the pending connection as a connected `QTcpSocket`. The function returns a pointer to a `QTcpSocket` in QAbstractSocket::ConnectedState that you can use for communicating with the client.

If an error occurs, `serverError` returns the type of error, and `errorString` can be called to get a human readable description of what happened.

When listening for connections, the address and port on which the server is listening are available as `serverAddress` and serverPort().

Calling `close` makes `QTcpServer` stop listening for incoming connections.

Although `QTcpServer` is mostly designed for use with an event loop, it's possible to use it without one. In that case, you must use waitForNewConnection(), which blocks until either a connection is available or a timeout expires.

See Also:
  `QTcpSocket`, `Server Example`, `Fortune Server Example`, `Example`, `Example`

Nested Class Summary
`static class` | `QTcpServer.Result`

Nested classes/interfaces inherited from class com.trolltech.qt.QSignalEmitter
`QSignalEmitter.AbstractSignal, QSignalEmitter.Signal0, QSignalEmitter.Signal1<A>, QSignalEmitter.Signal2<A,B>, QSignalEmitter.Signal3<A,B,C>, QSignalEmitter.Signal4<A,B,C,D>, QSignalEmitter.Signal5<A,B,C,D,E>, QSignalEmitter.Signal6<A,B,C,D,E,F>, QSignalEmitter.Signal7<A,B,C,D,E,F,G>, QSignalEmitter.Signal8<A,B,C,D,E,F,G,H>, QSignalEmitter.Signal9<A,B,C,D,E,F,G,H,I>`

Field Summary
`QSignalEmitter.Signal0` | `newConnection` This signal is emitted every time a new connection is available.

Constructor Summary
`QTcpServer()` Equivalent to `QTcpServer`(0).
`QTcpServer(QObject parent)` Constructs a `QTcpServer` object.

Method Summary
`void` | `close()` Closes the server.
`java.lang.String` | `errorString()` Returns a human readable description of the last error that occurred.
`static QTcpServer` | `fromNativePointer(QNativePointer nativePointer)` This function returns the QTcpServer instance pointed to by nativePointer
`boolean` | `hasPendingConnections()` Returns true if the server has a pending connection; otherwise returns false.
`protected void` | `incomingConnection(int handle)` This virtual function is called by `QTcpServer` when a new connection is available.
`boolean` | `isListening()` Returns true if the server is currently listening for incoming connections; otherwise returns false.
`boolean` | `listen(QHostAddress address, int port)` Tells the server to listen for incoming connections on address `address` and port `port`.
`int` | `maxPendingConnections()` Returns the maximum number of pending accepted connections.
`QTcpSocket` | `nextPendingConnection()` Returns the next pending connection as a connected `QTcpSocket` object.
`QNetworkProxy` | `proxy()` Returns the network proxy for this socket.
`QHostAddress` | `serverAddress()` Returns the server's address if the server is listening for connections; otherwise returns QHostAddress::Null.
`QAbstractSocket.SocketError` | `serverError()` Returns an error code for the last error that occurred.
`int` | `serverPort()` Returns the server's port if the server is listening for connections; otherwise, returns 0.
`void` | `setMaxPendingConnections(int numConnections)` Sets the maximum number of pending accepted connections to `numConnections`.
`void` | `setProxy(QNetworkProxy networkProxy)` Sets the explicit network proxy for this socket to `networkProxy`.
`boolean` | `setSocketDescriptor(int socketDescriptor)` Sets the socket descriptor this server should use when listening for incoming connections to `socketDescriptor`.
`int` | `socketDescriptor()` Returns the native socket descriptor the server uses to listen for incoming instructions, or -1 if the server is not listening.
`QTcpServer.Result` | `waitForNewConnection()` This is an overloaded method provided for convenience.
`QTcpServer.Result` | `waitForNewConnection(int msec)` Waits for at most `msec` milliseconds or until an incoming connection is available.

Methods inherited from class com.trolltech.qt.core.QObject
`blockSignals, childEvent, children, connectSlotsByName, customEvent, disposeLater, dumpObjectInfo, dumpObjectTree, dynamicPropertyNames, event, eventFilter, findChild, findChild, findChild, findChildren, findChildren, findChildren, findChildren, installEventFilter, isWidgetType, killTimer, moveToThread, objectName, parent, property, removeEventFilter, setObjectName, setParent, setProperty, signalsBlocked, startTimer, thread, timerEvent`

Methods inherited from class com.trolltech.qt.QtJambiObject
`dispose, disposed, finalize, reassignNativeResources, tr, tr, tr`

Methods inherited from class com.trolltech.qt.QSignalEmitter
`disconnect, disconnect, signalSender`

Methods inherited from class java.lang.Object
`clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface com.trolltech.qt.QtJambiInterface
`disableGarbageCollection, nativeId, nativePointer, reenableGarbageCollection, setJavaOwnership`

Field Detail

### newConnection

    public final QSignalEmitter.Signal0 newConnection

  This signal is emitted every time a new connection is available.

  Compatible Slot Signature:
    `void mySlot()`
  See Also:
    `hasPendingConnections`, `nextPendingConnection`

Constructor Detail

### QTcpServer

    public QTcpServer()

  Equivalent to `QTcpServer`(0).

### QTcpServer

    public QTcpServer(QObject parent)

  Constructs a `QTcpServer` object.

  `parent` is passed to the `QObject` constructor.

  See Also:
    `listen`, `setSocketDescriptor`

Method Detail

### close

    public final void close()

  Closes the server. The server will no longer listen for incoming connections.

  See Also:
    `listen`

### errorString

    public final java.lang.String errorString()

  Returns a human readable description of the last error that occurred.

  See Also:
    `serverError`

### isListening

    public final boolean isListening()

  Returns true if the server is currently listening for incoming connections; otherwise returns false.

  See Also:
    `listen`

### maxPendingConnections

    public final int maxPendingConnections()

  Returns the maximum number of pending accepted connections. The default is 30.

  See Also:
    `setMaxPendingConnections`, `hasPendingConnections`

### proxy

    public final QNetworkProxy proxy()

  Returns the network proxy for this socket. By default QNetworkProxy::DefaultProxy is used.

  See Also:
    `setProxy`, `QNetworkProxy`

### serverAddress

    public final QHostAddress serverAddress()

  Returns the server's address if the server is listening for connections; otherwise returns QHostAddress::Null.

  See Also:
    `serverPort`, `listen`

### serverError

    public final QAbstractSocket.SocketError serverError()

  Returns an error code for the last error that occurred.

  See Also:
    `errorString`

### setMaxPendingConnections

    public final void setMaxPendingConnections(int numConnections)

  Sets the maximum number of pending accepted connections to `numConnections`. `QTcpServer` will accept no more than `numConnections` incoming connections before `nextPendingConnection` is called. By default, the limit is 30 pending connections.

  Clients may still able to connect after the server has reached its maximum number of pending connections (i.e., `QTcpSocket` can still emit the connected() signal). `QTcpServer` will stop accepting the new connections, but the operating system may still keep them in queue.

  See Also:
    `maxPendingConnections`, `hasPendingConnections`

### setProxy

    public final void setProxy(QNetworkProxy networkProxy)

  Sets the explicit network proxy for this socket to `networkProxy`.

  To disable the use of a proxy for this socket, use the QNetworkProxy::NoProxy proxy type:

          server->setProxy(QNetworkProxy::NoProxy);

  See Also:
    `proxy`, `QNetworkProxy`

### setSocketDescriptor

    public final boolean setSocketDescriptor(int socketDescriptor)

  Sets the socket descriptor this server should use when listening for incoming connections to `socketDescriptor`. Returns true if the socket is set successfully; otherwise returns false.

  The socket is assumed to be in listening state.

  See Also:
    `socketDescriptor`, `isListening`

### socketDescriptor

    public final int socketDescriptor()

  Returns the native socket descriptor the server uses to listen for incoming instructions, or -1 if the server is not listening.

  If the server is using `QNetworkProxy`, the returned descriptor may not be usable with native socket functions.

  See Also:
    `setSocketDescriptor`, `isListening`

### hasPendingConnections

    public boolean hasPendingConnections()

  Returns true if the server has a pending connection; otherwise returns false.

  See Also:
    `nextPendingConnection`, `setMaxPendingConnections`

### incomingConnection

    protected void incomingConnection(int handle)

  This virtual function is called by `QTcpServer` when a new connection is available. The `handle` argument is the native socket descriptor for the accepted connection.

  The base implementation creates a `QTcpSocket`, sets the socket descriptor and then stores the `QTcpSocket` in an internal list of pending connections. Finally `newConnection` is emitted.

  Reimplement this function to alter the server's behavior when a connection is available.

  If this server is using `QNetworkProxy` then the `handle` may not be usable with native socket functions, and should only be used with QTcpSocket::setSocketDescriptor().

  See Also:
    `newConnection`, `nextPendingConnection`

### nextPendingConnection

    public QTcpSocket nextPendingConnection()

  Returns the next pending connection as a connected `QTcpSocket` object.

  The socket is created as a child of the server, which means that it is automatically deleted when the `QTcpServer` object is destroyed. It is still a good idea to delete the object explicitly when you are done with it, to avoid wasting memory.

  0 is returned if this function is called when there are no pending connections.

  See Also:
    `hasPendingConnections`

### fromNativePointer

    public static QTcpServer fromNativePointer(QNativePointer nativePointer)

  This function returns the QTcpServer instance pointed to by nativePointer

  Parameters:
    `nativePointer` - the QNativePointer of which object should be returned.

### listen

    public final boolean listen(QHostAddress address,
                                int port)

  Tells the server to listen for incoming connections on address `address` and port `port`. If `port` is 0, a port is chosen automatically. If `address` is QHostAddress::Any, the server will listen on all network interfaces.

  Returns true on success; otherwise returns false.

### serverPort

    public final int serverPort()

  Returns the server's port if the server is listening for connections; otherwise, returns 0.

### waitForNewConnection

    public final QTcpServer.Result waitForNewConnection(int msec)

  Waits for at most `msec` milliseconds or until an incoming connection is available. Returns true if a connection is available; otherwise returns false.

  This is a blocking function call. Its use is not adviced in a single-threaded GUI application, since the whole application will stop responding until the function returns. waitForNewConnection() is mostly useful when there is no event loop available.

  The non-blocking alternative is to connect to the newConnection() signal.

### waitForNewConnection

    public final QTcpServer.Result waitForNewConnection()

  This is an overloaded method provided for convenience.

  Returns:

Overview | Package | Class | Tree | Deprecated | Index | Help
Qt Jambi Home |
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD