Class: Concurrent::ErlangActor::Pid

Inherits:
Synchronization::Object
  • Object
show all
Defined in:
lib/concurrent-ruby-edge/concurrent/edge/erlang_actor.rb

Overview

The public reference of the actor which can be stored and passed around. Nothing else of the actor should be exposed. Functions#spawn_actor and Environment#spawn return the pid.

Instance Method Summary collapse

Instance Method Details

#ask(message, timeout = nil, timeout_value = nil) ⇒ Object, timeout_value

The actor is asked the message and blocks until a reply is available, which is returned by the method. If the reply is a rejection then the methods raises it.

If the actor does not call Environment#reply or Environment#reply_resolution the method will raise NoReply error. If the actor is terminated it will raise NoActor. Therefore the ask is never left unanswered and blocking.

Parameters:

  • message (Object)
  • timeout (Numeric) (defaults to: nil) —

    the maximum time in second to wait

  • timeout_value (Object) (defaults to: nil) —

    the value returned on timeout

Returns:

  • (Object, timeout_value) —

    reply to the message

Raises:



81
82
83
 
# File 'lib/concurrent-ruby-edge/concurrent/edge/erlang_actor.rb', line 81

def ask(message, timeout = nil, timeout_value = nil)
  @Actor.ask message, timeout, timeout_value
end

#ask_op(message, probe = Promises.resolvable_future) ⇒ Promises::Future(Object)

Same as #tell but represented as a Promises::Future.

Parameters:

  • message (Object)
  • probe (Promises::ResolvableFuture) (defaults to: Promises.resolvable_future) —

    a resolvable future which is resolved with the reply.

Returns:



90
91
92
 
# File 'lib/concurrent-ruby-edge/concurrent/edge/erlang_actor.rb', line 90

def ask_op(message, probe = Promises.resolvable_future)
  @Actor.ask_op message, probe
end

#name ⇒ #to_s?

Returns optional name of the actor.

Returns:

  • (#to_s, nil) —

    optional name of the actor



103
104
105
 
# File 'lib/concurrent-ruby-edge/concurrent/edge/erlang_actor.rb', line 103

def name
  @Name
end

#tell(message, timeout = nil) ⇒ self, ...

The actor is asynchronously told a message. The method returns immediately unless the actor has bounded mailbox and there is no more space for the message. Then the method blocks current thread until there is space available. This is useful for backpressure.

Parameters:

  • message (Object)
  • timeout (Numeric) (defaults to: nil) —

    the maximum time in second to wait

Returns:

  • (self, true, false) —

    self if timeout was nil, false on timing out and true if told in time.



56
57
58
 
# File 'lib/concurrent-ruby-edge/concurrent/edge/erlang_actor.rb', line 56

def tell(message, timeout = nil)
  @Actor.tell message, timeout
end

#tell_op(message) ⇒ Promises::Future(self)

Same as #tell but represented as a Promises::Future.

Parameters:

  • message (Object)

Returns:



63
64
65
 
# File 'lib/concurrent-ruby-edge/concurrent/edge/erlang_actor.rb', line 63

def tell_op(message)
  @Actor.tell_op(message)
end

#terminated ⇒ Promises::Future

Returns a future which is resolved with the final result of the actor that is either the reason for termination or a value if terminated normally.

Returns:

  • (Promises::Future) —

    a future which is resolved with the final result of the actor that is either the reason for termination or a value if terminated normally.



98
99
100
 
# File 'lib/concurrent-ruby-edge/concurrent/edge/erlang_actor.rb', line 98

def terminated
  @Actor.terminated
end

#to_s ⇒ String Also known as: inspect

Returns string representation.

Returns:

  • (String) —

    string representation



108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/concurrent-ruby-edge/concurrent/edge/erlang_actor.rb', line 108

def to_s
  original = super
  state    = case terminated.state
             when :pending
               'running'
             when :fulfilled
               "terminated normally with #{terminated.value}"
             when :rejected
               "terminated because of #{terminated.reason}"
             else
               raise
             end
  [original[0..-2], *@Name, state].join(' ') << '>'
end