Module espace

Description
Function Index
Function Details

This module provides the client access to the user applications.

Authors: Fred Youhanaie (fyrlang@anydata.co.uk).

Description

This module provides the client access to the user applications.

In order to run any espace based applications the application needs to be started using one of the start/0,1 functions.

Multiple independent instances of espace can be active within the same node without interfering with each other. There can be up to one unnamed instance, and as many named instance as desired. Instance names are short atoms that are appended to the various server and table names.

All client functions here have two variants, with and without instance name. If no instance name is supplied, or if the instance name is espace, then the unnamed instance is assumed.

Function Index

eval/1	Perform an `eval` operation via the unnamed espace server.
eval/2	Perform an `eval` operation via a named espace server.
in/1	Perform an `in` operation via the unnamed espace server.
in/2	Perform an `in` operation via a named espace server.
infile/1	Read and process an espace input file via the unnamed server.
infile/2	Read and process an espace input file via a named server.
inp/1	Perform an `inp` operation via the unnamed espace server.
inp/2	Perform an `inp` operation via a named espace server.
out/1	Perform an `out` operation via the unnamed espace server.
out/2	Perform an `out` operation via a named espace server.
rd/1	Perform a `rd` operation via the unnamed espace server.
rd/2	Perform a `rd` operation via a named espace server.
rdp/1	Perform a `rdp` operation via the unnamed espace server.
rdp/2	Perform a `rdp` operation via a named espace server.
start/0	Start a new unnamed instance of espace.
start/1	Start a new named instance of espace.
stop/0	Stop the unnamed instance of espace.
stop/1	Stop a named instance of espace.
worker/1	start a new worker process via the unnamed espace server.
worker/2	start a new worker process via a named espace server.

Function Details

eval/1

eval(Tuple::tuple()) -> pid()

Perform an eval operation via the unnamed espace server.

See eval/2 for details.

eval/2

eval(Inst_name::atom(), Tuple::tuple()) -> pid()

Perform an eval operation via a named espace server.

The input Tuple is evaluated in a worker process and the result is sent to the tuple space using out operation.

The function returns the pid of the worker process.

The elements of the output tuple correspond to those of Tuple. If any of the elements of Tuple match the function pattern, then the corresponding output element will be the value of the function.

The following patterns will trigger the evaluation of the second element of the tuple:

Anonymous function, e.g. {aa, fun () -> 2+3 end, zz}.
Tuple with function and args, e.g. {aa, {fun (X,Y) -> X+Y end, [2, 3]}, zz}

Both examples above will produce {aa, 5, zz}

In the first example we have a fun expression of arity zero. In the second, we have a pair (tuple) of a fun expression and a list, and the arity of the fun matches the length of the list.

Any other pattern will move the element to the output tuple untouched.

in/1

in(Pattern::tuple()) -> {list(), tuple()} | quit

Perform an in operation via the unnamed espace server.

See in/2 for details.

in/2

in(Inst_name::atom(), Pattern::tuple()) -> {list(), tuple()} | quit

Perform an in operation via a named espace server.

For details of possible patterns see the match_spec in ets:match/2,3. Pattern must be a tuple. It may consist of expressions, or it may contain $N pattern variables, where N>0.

If the pattern does not match a tuple in the tuple space, then the call will block until such a pattern is added to the tuple space. If the espace server terminates while the client is in blocking state the atom quit will be returned.

If a match is found, the tuple is returned as a pair {List, Tuple}, where Tuple is the whole tuple, and List is a, possibly empty, list containing the matched $N pattern variables. The items in the list will be ordered by the $N variable numbers.

For example the tuple {add, 34, 88} will match the pattern {add, '$2', '$1'}, and the returned result will be '{[88, 34], {add, 34, 88}}'. Note the order of the numbers in the list.

The matched tuple will be removed from the tuple space.

infile/1

infile(File::file:name_all()) -> ok

Read and process an espace input file via the unnamed server.

See infile/2 for details.

infile/2

infile(Inst_name::atom(), File::file:name_all()) -> ok

Read and process an espace input file via a named server.

The file should be a valid Erlang terms file.

inp/1

inp(Pattern::tuple()) -> nomatch | {list(), tuple()}

Perform an inp operation via the unnamed espace server.

See inp/2 for details.

inp/2

inp(Inst_name::atom(), Pattern::tuple()) -> nomatch | {list(), tuple()}

Perform an inp operation via a named espace server.

The inp/1,2 functions are the non-blocking versions of in/1,2`. If a match is not found in the first instance, then the atom `nomatch is returned. If a match is found, then it will be removed from the tuple space and returned as a {List, Tuple} pair.

See in/1,2 for details and examples of the match patterns.

out/1

out(Tuple::tuple()) -> done

Perform an out operation via the unnamed espace server.

See out/2 for details.

out/2

out(Inst_name::atom(), Tuple::tuple()) -> done

Perform an out operation via a named espace server.

The Tuple supplied as argument will be added to the tuple space. Duplicate tuples are allowed in the tuple space.

rd/1

rd(Pattern::tuple()) -> {list(), tuple()} | quit

Perform a rd operation via the unnamed espace server.

See rd/2 for details.

rd/2

rd(Inst_name::atom(), Pattern::tuple()) -> {list(), tuple()} | quit

Perform a rd operation via a named espace server.

The rd/1,2 functions behave in the same manner as in/1,2 except that when a matching tuple is found, it will not be removed from the tuple space.

rdp/1

rdp(Pattern::tuple()) -> nomatch | {list(), tuple()}

Perform a rdp operation via the unnamed espace server.

See rdp/2 for details.

rdp/2

rdp(Inst_name::atom(), Pattern::tuple()) -> nomatch | {list(), tuple()}

Perform a rdp operation via a named espace server.

The functions rdp/1,2 are the non-blocking versions of rd/1,2. That is, if a match is not found, then nomatch is returned, and if a match is found the matching tuple will be return, but it will not be removed from the tuple space.

See worker/2 for details.

worker/2

worker(Inst_name::atom(), X2::tuple()) -> pid()

start a new worker process via a named espace server.

The function expects a single tuple as argument, which can have one of the following forms:

A {Mod, Fun, Args} triple, e.g. {adder1, test_add2, []}.
A single fun without args, e.g. {fun () -> adder1:test_add2() end}, or {fun adder1:test_add2/0}.
A single fun with args, e.g. {fun (A,B) -> adder1:test_add2(A,B) end}, or {fun adder1:test_add2/2, [A,B]}.
A string containing a fun, e.g. "fun () -> adder1:test_add2() end.". This is mainly for use in espace input files.

Generated by EDoc