ThreadedSocketService

A #GThreadedSocketService is a simple subclass of #GSocketService that handles incoming connections by creating a worker thread and dispatching the connection to it by emitting the #GThreadedSocketService::run signal in the new thread.

The signal handler may perform blocking IO and need not return until the connection is closed.

The service is implemented using a thread pool, so there is a limited amount of threads available to serve incoming requests. The service automatically stops the #GSocketService from accepting new connections when all threads are busy.

As with #GSocketService, you may connect to #GThreadedSocketService::run, or subclass and override the default handler.

class ThreadedSocketService : SocketService {

protected

GThreadedSocketService* gThreadedSocketService;

GThreadedSocketService* getThreadedSocketServiceStruct();

void* getStruct();

void setStruct(GObject* obj);

this(GThreadedSocketService* gThreadedSocketService, bool ownedRef);

static GType getType();

this(int maxThreads);

int[string] connectedSignals;

bool delegate(SocketConnection, ObjectG, ThreadedSocketService)[] onRunListeners;

void addOnRun(bool delegate(SocketConnection, ObjectG, ThreadedSocketService) dlg, ConnectFlags connectFlags);

static int callBackRun(GThreadedSocketService* threadedsocketserviceStruct, GSocketConnection* connection, GObject* sourceObject, ThreadedSocketService _threadedsocketservice);

}

Constructors

this this(GThreadedSocketService* gThreadedSocketService, bool ownedRef): Sets our main struct and passes it to the parent class.
this this(int maxThreads): Creates a new #GThreadedSocketService with no listeners. Listeners must be added with one of the #GSocketListener "add" methods.

Members

Functions

addOnRun void addOnRun(bool delegate(SocketConnection, ObjectG, ThreadedSocketService) dlg, ConnectFlags connectFlags): The ::run signal is emitted in a worker thread in response to an incoming connection. This thread is dedicated to handling @connection and may perform blocking IO. The signal handler need not return until the connection is closed.
getStruct void* getStruct(): the main Gtk struct as a void*
getThreadedSocketServiceStruct GThreadedSocketService* getThreadedSocketServiceStruct(): Get the main Gtk struct
setStruct void setStruct(GObject* obj): Undocumented in source. Be warned that the author may not have intended to support it.

Static functions

callBackRun int callBackRun(GThreadedSocketService* threadedsocketserviceStruct, GSocketConnection* connection, GObject* sourceObject, ThreadedSocketService _threadedsocketservice): Undocumented in source. Be warned that the author may not have intended to support it.
getType GType getType()

Variables

connectedSignals int[string] connectedSignals;: Undocumented in source.
gThreadedSocketService GThreadedSocketService* gThreadedSocketService;: the main Gtk struct
onRunListeners bool delegate(SocketConnection, ObjectG, ThreadedSocketService)[] onRunListeners;: Undocumented in source.

Inherited Members

From SocketService

gSocketService GSocketService* gSocketService;: the main Gtk struct
getSocketServiceStruct GSocketService* getSocketServiceStruct(): Get the main Gtk struct
getStruct void* getStruct(): the main Gtk struct as a void*
setStruct void setStruct(GObject* obj): Undocumented in source. Be warned that the author may not have intended to support it.
getType GType getType()
isActive bool isActive(): Check whether the service is active or not. An active service will accept new clients that connect, while a non-active service will let connecting clients queue up until the service is started.
start void start(): Starts the service, i.e. start accepting connections from the added sockets when the mainloop runs.
stop void stop(): Stops the service, i.e. stops accepting connections from the added sockets when the mainloop runs.
connectedSignals int[string] connectedSignals;: Undocumented in source.
onIncomingListeners bool delegate(SocketConnection, ObjectG, SocketService)[] onIncomingListeners;: Undocumented in source.
addOnIncoming void addOnIncoming(bool delegate(SocketConnection, ObjectG, SocketService) dlg, ConnectFlags connectFlags): The ::incoming signal is emitted when a new incoming connection to @service needs to be handled. The handler must initiate the handling of @connection, but may not block; in essence, asynchronous operations must be used.
callBackIncoming int callBackIncoming(GSocketService* socketserviceStruct, GSocketConnection* connection, GObject* sourceObject, SocketService _socketservice): Undocumented in source. Be warned that the author may not have intended to support it.