123456789_123456789_123456789_123456789_123456789_

Class: Concurrent::Actor::Reference

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain:
self, PublicDelegations, TypeCheck
Inherits: Object
Defined in: lib/concurrent-ruby-edge/concurrent/actor/reference.rb

Overview

Reference is public interface of Actor instances. It is used for sending messages and can be freely passed around the application. It also provides some basic information about the actor, see PublicDelegations.

AdHoc.spawn('printer') { -> message { puts message } }
# => #<Concurrent::Actor::Reference:0x7fd0d2883218 /printer (Concurrent::Actor::Utils::AdHoc)>
#                                   ^object_id     ^path     ^context class

Class Method Summary

Instance Attribute Summary

Instance Method Summary

PublicDelegations - Included

#actor_class

Alias for PublicDelegations#context_class.
#context_class, #executor, #name, #parent, #path,
#ref

Alias for PublicDelegations#reference.
#reference

TypeCheck - Included

#Child!, #Child?, #Match!, #Match?, #Type!, #Type?

Constructor Details

.new(core) ⇒ Reference (private)

[ GitHub ] 

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 22



def initialize(core)
  @core = Type! core, Core
end


  







Instance Attribute Details



  

    #core   (readonly, private)
  

  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 18



attr_reader :core


  







Instance Method Details



  

    #<<(message)  
  



  

    

Alias for #tell.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 39



alias_method :<<, :tell


  








  

    #==(other)  
  

  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 98



def ==(other)
  Type? other, self.class and other.send(:core) == core
end


  








  

    #ask(message, future = Concurrent::Promises.resolvable_future)  ⇒ Promises::Future 
    Also known as: #ask_op
  



  

    
  

    Note:
    


it’s a good practice to use #tell whenever possible. Results can be sent back with other messages. Ask should be used only for testing and when it returns very shortly. It can lead to deadlock if all threads in global_io_executor will block on while asking. It’s fine to use it form outside of actors and global_io_executor.



  



  





    

    
Examples:

      
adder = AdHoc.spawn('adder') { -> message { message + 1 } }
adder.ask(1).value # => 2
adder.ask(nil).wait.reason # => #<NoMethodError: undefined method `+' for nil:NilClass>

  


Parameters:


    
  
  • 
    message
    (Object)
  
    • 
  
  • 
    future
    (Promises::Future)
    (defaults to: Concurrent::Promises.resolvable_future)
—    
    

    to be fulfilled be message’s processing result
    

    
  
    • 



Returns:





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 52



def ask(message, future = Concurrent::Promises.resolvable_future)
  message message, future
end


  








  

    #ask!(message, future = Concurrent::Promises.resolvable_future)  ⇒ Object 
  



  

    
  

    Note:
    


it’s a good practice to use #tell whenever possible. Results can be sent back with other messages. Ask should be used only for testing and when it returns very shortly. It can lead to deadlock if all threads in global_io_executor will block on while asking. It’s fine to use it form outside of actors and global_io_executor.



  




Sends the message synchronously and blocks until the message is processed. Raises on error.


  





    

    
Examples:

      
adder = AdHoc.spawn('adder') { -> message { message + 1 } }
adder.ask!(1) # => 2

  


Parameters:


    
  
  • 
    message
    (Object)
  
    • 
  
  • 
    future
    (Promises::Future)
    (defaults to: Concurrent::Promises.resolvable_future)
—    
    

    to be fulfilled be message’s processing result
    

    
  
    • 



Returns:


    
  
  • 
    (Object)
—    
    

    message’s processing result
    

    
  
    • 



Raises:


    
  
  • 
    (Exception)
—    
    

    future.reason if future is #rejected?
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 73



def ask!(message, future = Concurrent::Promises.resolvable_future)
  ask(message, future).value!
end


  








  

    #ask_op(message, future = Concurrent::Promises.resolvable_future)  
  



  

    

Alias for #ask.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 57



alias_method :ask_op, :ask


  








  

    #dead_letter_routing  
  



  

    
  





    
See Also:

  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 88



def dead_letter_routing
  core.dead_letter_routing
end


  








  

    #inspect  
  



  

    

Alias for #to_s.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 96



alias_method :inspect, :to_s


  








  

    #map(messages)  
  

  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 77



def map(messages)
  messages.map { |m| self.ask(m) }
end


  








  

    #message(message, future = nil)  
  



  

    

behaves as #tell when no future and as #ask when future


  





  


  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 82



def message(message, future = nil)
  core.on_envelope Envelope.new(message, future, Actor.current || Thread.current, self)
  return future ? future.with_hidden_resolvable : self
end


  








  

    #tell(message)  ⇒ Reference 
    Also known as: #<<
  



  

    

Sends the message asynchronously to the actor and immediately returns self (the reference) allowing to chain message telling.


  





    

    
Examples:

      
printer = AdHoc.spawn('printer') { -> message { puts message } }
printer.tell('ping').tell('pong')
printer << 'ping' << 'pong'
# => 'ping'\n'pong'\n'ping'\n'pong'\n

  


Parameters:



Returns:


    
  
  • 
    (Reference)
—    
    

    self
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 35



def tell(message)
  message message, nil
end


  








  

    #to_s  
    Also known as: #inspect
  

  [ GitHub ]


  

  


# File 'lib/concurrent-ruby-edge/concurrent/actor/reference.rb', line 92



def to_s
  format '%s %s (%s)>', super[0..-2], path, actor_class
end