NAME

       ose - Interface module for OSE messaging and process monitoring from Erlang.

DESCRIPTION

       Interface module for OSE messaging and process monitoring from Erlang

       For  each  mailbox  created through open/1 a OSE phantom process with that name is started. Since phantom
       processes are used the memory footprint of each mailbox is quite small.

       To receive messages you first have to subscribe to the specific message numbers that you  are  interested
       in with listen/2. The messages will be sent to the Erlang process that created the mailbox.

DATA TYPES

         attach_ref():

           Reference  from  an attach request. This term will be included in the term returned when the attached
           mailbox disappears.

         hunt_ref():

           Reference from a hunt request. This term will be included in a successful hunt response.

         mailbox():

           Mailbox handle. Implemented as an erlang port.

         mailbox_id():

           Mailbox ID, this is the same as the process id of an OSE process. An integer.

         message_number() = 0..4294967295:

           OSE Signal number

EXPORTS

       attach(Port, Pid) -> Ref

              Types:

                 Port = mailbox()
                 Pid = mailbox_id()
                 Ref = attach_ref()

              Attach to an OSE process.

              Will send {mailbox_down, Port, Ref, MboxId} to the calling process if the OSE process exits.

              Returns a reference that can be used to cancel the attachment using detach/2.

              raises: badarg | enomem

       close(Port) -> ok

              Types:

                 Port = mailbox()

              Close a mailbox

              This kills the OSE phantom process associated with this mailbox.

              Will also consume any {'EXIT',Port,_} message from the port that comes due  to  the  port  closing
              when the calling process traps exits.

              raises: badarg

       dehunt(Port, Ref) -> ok

              Types:

                 Port = mailbox()
                 Ref = hunt_ref()

              Stop hunting for OSE process.

              If  a  message  for this hunt has been sent but not received by the calling process, it is removed
              from the message queue. Note that this only works if the same process that did the hunt  does  the
              dehunt.

              raises: badarg

              See also: hunt/2.

       detach(Port, Ref) -> ok

              Types:

                 Port = mailbox()
                 Ref = attach_ref()

              Remove attachment to an OSE process.

              If a message for this monitor has been sent but not received by the calling process, it is removed
              from the message queue. Note that this only works of the same process that did the attach does the
              detach.

              raises: badarg

              See also: attach/2.

       get_id(Port) -> Pid

              Types:

                 Port = mailbox()
                 Pid = mailbox_id()

              Get the mailbox id for the given port.

              The  mailbox  id  is  the  same as the OSE process id of the OSE phantom process that this mailbox
              represents.

              raises: badarg

       get_name(Port, Pid) -> Name | undefined

              Types:

                 Port = mailbox()
                 Pid = mailbox_id()
                 Name = binary()

              Get the mailbox name for the given mailbox id.

              The mailbox name is the name of the OSE process with process id Pid.

              This call will fail with badarg if the underlying system does not support getting the name from  a
              process id.

              raises: badarg

       hunt(Port, HuntPath) -> Ref

              Types:

                 Port = mailbox()
                 HuntPath = iodata()
                 Ref = hunt_ref()

              Hunt for OSE process by name.

              Will  send  {mailbox_up,  Port,  Ref,  MboxId} to the calling process when the OSE process becomes
              available.

              Returns a reference term that can be used to cancel the hunt using dehunt/2.

              raises: badarg

       listen(Port, SigNos) -> ok

              Types:

                 Port = mailbox()
                 SigNos = [message_number()]

              Start listening for specified OSE signal numbers.

              The mailbox will  send  {message,Port,{FromMboxId,ToMboxId,MsgNo,MsgData}}  to  the  process  that
              created the mailbox when an OSE message with any of the specified SigNos arrives.

              Repeated calls to listen will replace the current set of signal numbers to listen to. i.e

                   1>ose:listen(MsgB,[1234,12345]).
                 ok
                 2> ose:listen(MsgB,[1234,123456]).
                 ok.

              The  above  will  first listen for signals with numbers 1234 and 12345, and then replace that with
              only listening to 1234 and 123456.

              With the current implementation it is not possible to listen to all signal numbers.

              raises: badarg | enomem

       open(Name) -> Port

              Types:

                 Name = iodata()
                 Port = mailbox()

              Create a mailbox with the given name and return a port that handles the mailbox.

              An OSE phantom process with the given name will be  created  that  will  send  any  messages  sent
              through  this mailbox. Any messages sent to the new OSE process will automatically be converted to
              an Erlang message and sent to the Erlang process  that  calls  this  function.  See  listen/2  for
              details about the format of the message sent.

              The caller gets linked to the created mailbox.

              raises: badarg | system_limit

              See also: listen/2.

       send(Port, Pid, SigNo, SigData) -> ok

              Types:

                 Port = mailbox()
                 Pid = mailbox_id()
                 SigNo = message_number()
                 SigData = iodata()

              Send an OSE message.

              The message is sent from the OSE process' own ID that is: get_id(Port).

              raises: badarg

              See also: send/5.

       send(Port, Pid, SenderPid, SigNo, SigData) -> ok

              Types:

                 Port = mailbox()
                 Pid = mailbox_id()
                 SenderPid = mailbox_id()
                 SigNo = message_number()
                 SigData = iodata()

              Send an OSE message with different sender.

              As send/4 but the sender will be SenderPid.

              raises: badarg

              See also: send/4.

AUTHORS

       <>

                                                     ose 1.1                                           ose(3erl)