category

`linda_server`

Linda server predicates and tuple-space state. Import into a threaded object together with the linda_client category.

Availability:

logtalk_load(linda(loader))

Author: Paulo Moura
Version: 2:0:0
Date: 2026-03-27

Compilation flags:

static

Provides:

logtalk::message_prefix_stream/4

Uses:

list
logtalk
os
socket

Remarks:

(none)

Inherited public predicates:

(none)

Public predicates 

`linda/1`

Starts a Linda server with the given options. The predicate succeeds when all clients have disconnected after a shutdown request.

Compilation flags:

static

Template:

linda(Options)

Meta-predicate template:

linda(::)

Mode and number of proofs:

linda(+list) - one

Remarks:

Option port(Port): Use Port as the server port. Must be an integer and an available port.

Option Address-Goal: Address is unified with Host:Port and Goal is called when the server starts. Useful for saving the address or starting clients.

Option accept_hook(Client,Input,Output,Goal): When a client connects, Client is unified with the client address, Input and Output with the connection streams, and Goal is called. If Goal fails, the connection is rejected.

Starts a Linda server on an automatically assigned port using default options. The server address (Host:Port) is written to the current output stream. The predicate succeeds when all clients have disconnected after a shutdown request.

Compilation flags:

static

Mode and number of proofs:

linda - one

Protected predicates 

(no local declarations; see entity ancestors if any)

Private predicates 

`server_socket_/1`

Stores the server socket descriptor.

Compilation flags:

dynamic

Template:

server_socket_(ServerSocket)

Mode and number of proofs:

server_socket_(?term) - zero_or_one

`client_connection_/3`

Stores active client connections. Each client has an ID, input stream, and output stream.

Compilation flags:

dynamic

Template:

client_connection_(ClientId,InputStream,OutputStream)

Mode and number of proofs:

client_connection_(?term,?term,?term) - zero_or_more

`accept_hook_/1`

Stores the optional accept hook goal to call when a client connects.

Compilation flags:

dynamic

Template:

accept_hook_(Hook)

Mode and number of proofs:

accept_hook_(?callable) - zero_or_one

`server_running_/1`

Flag indicating the server is running.

Compilation flags:

dynamic

Template:

server_running_(Address)

Mode and number of proofs:

server_running_(?address) - zero_or_one

`server_shutdown_/0`

Flag indicating the server has received a shutdown request.

Compilation flags:

dynamic

Mode and number of proofs:

server_shutdown_ - zero_or_one

`tuple_/1`

Stores tuples in the Linda tuple space.

Compilation flags:

dynamic

Template:

tuple_(Tuple)

Mode and number of proofs:

tuple_(?term) - zero_or_more

`waiting_/3`

Stores blocked clients waiting for tuples. Records the client ID, request pattern, and output stream.

Compilation flags:

dynamic

Template:

waiting_(ClientId,Request,OutputStream)

Mode and number of proofs:

waiting_(?term,?term,?term) - zero_or_more

`client_engine_/2`

Maps client IDs to their corresponding threaded engine names.

Compilation flags:

dynamic

Template:

client_engine_(ClientId,EngineName)

Mode and number of proofs:

client_engine_(?term,?atom) - zero_or_more

`ts_out/1`

Synchronized predicate to add a tuple to the tuple space and wake waiting clients.

Compilation flags:

static, synchronized

Template:

ts_out(Tuple)

Mode and number of proofs:

ts_out(+term) - one

`ts_in/4`

Synchronized predicate to remove a matching tuple or register a waiting client.

Compilation flags:

static, synchronized

Template:

ts_in(Tuple,ClientId,OutputStream,Found)

Mode and number of proofs:

ts_in(+term,+term,+term,-compound) - one

`ts_in_noblock/2`

Synchronized predicate to try removing a matching tuple without blocking.

Compilation flags:

static, synchronized

Template:

ts_in_noblock(Tuple,Found)

Mode and number of proofs:

ts_in_noblock(+term,-compound) - zero_or_one

`ts_in_list/4`

Synchronized predicate to remove a tuple matching one of multiple patterns or register a waiting client.

Compilation flags:

static, synchronized

Template:

ts_in_list(TupleList,ClientId,OutputStream,Found)

Mode and number of proofs:

ts_in_list(+list,+term,+term,-compound) - one

`ts_rd/4`

Synchronized predicate to read a matching tuple or register a waiting client.

Compilation flags:

static, synchronized

Template:

ts_rd(Tuple,ClientId,OutputStream,Found)

Mode and number of proofs:

ts_rd(+term,+term,+term,-compound) - one

`ts_rd_noblock/2`

Synchronized predicate to try reading a matching tuple without blocking.

Compilation flags:

static, synchronized

Template:

ts_rd_noblock(Tuple,Found)

Mode and number of proofs:

ts_rd_noblock(+term,-compound) - zero_or_one

`ts_rd_list/4`

Synchronized predicate to read a tuple matching one of multiple patterns or register a waiting client.

Compilation flags:

static, synchronized

Template:

ts_rd_list(TupleList,ClientId,OutputStream,Found)

Mode and number of proofs:

ts_rd_list(+list,+term,+term,-compound) - one

`ts_findall_rd_noblock/3`

Synchronized predicate to collect all tuples matching a pattern.

Compilation flags:

static, synchronized

Template:

ts_findall_rd_noblock(Template,Tuple,List)

Mode and number of proofs:

ts_findall_rd_noblock(+term,+term,-list) - zero_or_more

`ts_findall_in_noblock/3`

Synchronized predicate to collect and remove all tuples matching a pattern.

Compilation flags:

static, synchronized

Template:

ts_findall_in_noblock(Template,Tuple,List)

Mode and number of proofs:

ts_findall_in_noblock(+term,+term,-list) - zero_or_more

Operators 

(none)

linda_server

`linda_server`