Client

The clients are one or more SICStus processes which have connection(s) to the server.

To load the package, enter the query

     | ?- use_module(library('linda/client')).
     

Some of the following predicates fail if they don't receive an answer from the Linda-server in a reasonable amount of time. That time is set with the predicate linda_timeout/2.

linda_client(+Address)

Establishes a connection to a Linda-server specified by Address. The Address is of the format Host:PortNumber as given by linda/[0,1] and linda/1.

It is not possible to be connected to two Linda-servers at the same time.

This predicate can fail due to a timeout.

close_client

Closes the connection to the server.

shutdown_server/0

Sends a Quit signal to the server, which keeps running after receiving this signal, until such time as all the clients have closed their connections. It is up to the clients to tell each other to quit. When all the clients are done, the server stops (i.e. linda/[0,1] succeeds). Courtesy of Malcolm Ryan. Note that close_client/0 should be called after shutdown_server/0. shutdown_server/0 will raise an error if there is no connection between the client and the server.

linda_timeout(?OldTime, ?NewTime)

This predicate controls Linda's timeout. OldTime is unified with the old timeout and then timeout is set to NewTime. The value is either off or of the form Seconds:Milliseconds. The former value indicates that the timeout mechanism is disabled, that is, eternal waiting. The latter form is the timeout-time.

out(+Tuple)

Places the tuple Tuple in Linda's tuple-space.

in(?Tuple)

Removes the tuple Tuple from Linda's tuple-space if it is there. If not, the predicate blocks until it is available (that is, someone performs an out/1).

in_noblock(?Tuple)

Removes the tuple Tuple from Linda's tuple-space if it is there. If not, the predicate fails.

This predicate can fail due to a timeout.

in(+TupleList, ?Tuple)

As in/1 but succeeds when either of the tuples in TupleList is available. Tuple is unified with the fetched tuple. If that unification fails, the tuple is not reinserted in the tuple-space.

rd(?Tuple)

Succeeds if Tuple is available in the tuple-space, suspends otherwise until it is available. Compare this with in/1: the tuple is not removed.

rd_noblock(?Tuple)

Succeeds if Tuple is available in the tuple-space, fails otherwise.

This predicate can fail due to a timeout.

rd(+TupleList, ?Tuple)

As in/2 but does not remove any tuples.

bagof_rd_noblock(?Template, +Tuple, ?Bag)

Bag is the list of all instances of Template such that Tuple exists in the tuple-space.

The behavior of variables in Tuple and Template is as in bagof/3. The variables could be existentially quantified with ^/2 as in bagof/3.

The operation is performed as an atomic operation.

This predicate can fail due to a timeout.

Example: Assume that only one client is connected to the server and that the tuple-space initially is empty.

          | ?- out(x(a,3)), out(x(a,4)), out(x(b,3)), out(x(c,3)).
          
          yes
          | ?- bagof_rd_noblock(C-N, x(C,N), L).
          
          C = _32,
          L = [a-3,a-4,b-3,c-3],
          N = _52 ?
          
          yes
          | ?- bagof_rd_noblock(C, N^x(C,N), L).
          
          C = _32,
          L = [a,a,b,c],
          N = _48 ?
          
          yes