Class List Method List File List

# Class: Vertx::EventBus

Inherits:
  Object
  - Object
  - Vertx::EventBus
  show all
Includes:
  Measured
Defined in:
  /Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb

## Overview

A Vert.x event-bus is a light-weight distributed messaging system which allows different parts of your application, or different applications and services to communicate with each in a loosely coupled way.

An event-bus supports publish-subscribe messaging, point-to-point messaging and request-response messaging.

Message delivery is best-effort and messages can be lost if failure of all or part of the event bus occurs.

Please refer to the documentation for more information on the event bus.

## Constant Summary

@@j_api_type =

      Object.new

## Class Method Summary (collapse)

- + (Boolean) accept?(obj)
- + (Object) j_api_type
- + (Object) j_class
- + (Object) unwrap(obj)
- + (Object) wrap(obj)

## Instance Method Summary (collapse)

- - (::Vertx::EventBus) add_interceptor { ... }
  Add an interceptor that will be called whenever a message is sent from Vert.x.
- - (::Vertx::MessageConsumer) consumer(address = nil) { ... }
  Create a consumer and register it against the specified address.
- - (::Vertx::MessageConsumer) local_consumer(address = nil) { ... }
  Like #consumer but the address won't be propagated across the cluster.
- - (true, false) metrics_enabled?
  Whether the metrics are enabled for this measured object.
- - (self) publish(address = nil, message = nil, options = nil)
  Like #publish but specifying options that can be used to configure the delivery.
- - (::Vertx::MessageProducer) publisher(address = nil, options = nil)
  Like #publisher but specifying delivery options that will be used for configuring the delivery of the message.
- - (::Vertx::EventBus) remove_interceptor { ... }
  Remove an interceptor.
- - (self) send(address = nil, message = nil, options = nil) { ... }
  Like #send but specifying a replyHandler that will be called if the recipient subsequently replies to the message.
- - (::Vertx::MessageProducer) sender(address = nil, options = nil)
  Like #sender but specifying delivery options that will be used for configuring the delivery of the message.

## Class Method Details

### + (`Boolean`) accept?(obj)

Returns:

- (`Boolean`)

    30
    31
    32
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 30

    def @@j_api_type.accept?(obj)
      obj.class == EventBus
    end

### + (`Object`) j_api_type

    39
    40
    41
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 39

    def self.j_api_type
      @@j_api_type
    end

### + (`Object`) j_class

    42
    43
    44
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 42

    def self.j_class
      Java::IoVertxCoreEventbus::EventBus.java_class
    end

### + (`Object`) unwrap(obj)

    36
    37
    38
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 36

    def @@j_api_type.unwrap(obj)
      obj.j_del
    end

### + (`Object`) wrap(obj)

    33
    34
    35
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 33

    def @@j_api_type.wrap(obj)
      EventBus.new(obj)
    end

## Instance Method Details

### - (`::Vertx::EventBus`) add_interceptor { ... }

Add an interceptor that will be called whenever a message is sent from Vert.x

Yields:

- the interceptor

Returns:

- (`::Vertx::EventBus`) —
  a reference to this, so the API can be used fluently

Raises:

- (`ArgumentError`)

    144
    145
    146
    147
    148
    149
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 144

    def add_interceptor
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:addInterceptor, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::SendContext)) })),::Vertx::EventBus)
      end
      raise ArgumentError, "Invalid arguments when calling add_interceptor()"
    end

### - (`::Vertx::MessageConsumer`) consumer(address = nil) { ... }

Create a consumer and register it against the specified address.

Parameters:

- address (`String`) (defaults to: `nil`) —
  the address that will register it at

Yields:

- the handler that will process the received messages

Returns:

- (`::Vertx::MessageConsumer`) —
  the event bus message consumer

Raises:

- (`ArgumentError`)

    95
    96
    97
    98
    99
    100
    101
    102
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 95

    def consumer(address=nil)
      if address.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:consumer, [Java::java.lang.String.java_class]).call(address),::Vertx::MessageConsumer, nil)
      elsif address.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:consumer, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(address,(Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Message, nil)) })),::Vertx::MessageConsumer, nil)
      end
      raise ArgumentError, "Invalid arguments when calling consumer(#{address})"
    end

### - (`::Vertx::MessageConsumer`) local_consumer(address = nil) { ... }

Like #consumer but the address won't be propagated across the cluster.

Parameters:

- address (`String`) (defaults to: `nil`) —
  the address that will register it at

Yields:

- the handler that will process the received messages

Returns:

- (`::Vertx::MessageConsumer`) —
  the event bus message consumer

Raises:

- (`ArgumentError`)

    107
    108
    109
    110
    111
    112
    113
    114
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 107

    def local_consumer(address=nil)
      if address.class == String && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:localConsumer, [Java::java.lang.String.java_class]).call(address),::Vertx::MessageConsumer, nil)
      elsif address.class == String && block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:localConsumer, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(address,(Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Message, nil)) })),::Vertx::MessageConsumer, nil)
      end
      raise ArgumentError, "Invalid arguments when calling local_consumer(#{address})"
    end

### - (`true`, `false`) metrics_enabled?

Whether the metrics are enabled for this measured object

Returns:

- (`true`, `false`) —
  true if the metrics are enabled

Raises:

- (`ArgumentError`)

    47
    48
    49
    50
    51
    52
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 47

    def metrics_enabled?
      if !block_given?
        return @j_del.java_method(:isMetricsEnabled, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling metrics_enabled?()"
    end

### - (`self`) publish(address = nil, message = nil, options = nil)

Like #publish but specifying `options` that can be used to configure the delivery.

Parameters:

- address (`String`) (defaults to: `nil`) —
  the address to publish it to
- message (`Object`) (defaults to: `nil`) —
  the message, may be `null`
- options (`Hash`) (defaults to: `nil`) —
  the delivery options

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 81

    def publish(address=nil,message=nil,options=nil)
      if address.class == String && ::Vertx::Util::unknown_type.accept?(message) && !block_given? && options == nil
        @j_del.java_method(:publish, [Java::java.lang.String.java_class,Java::java.lang.Object.java_class]).call(address,::Vertx::Util::Utils.to_object(message))
        return self
      elsif address.class == String && ::Vertx::Util::unknown_type.accept?(message) && options.class == Hash && !block_given?
        @j_del.java_method(:publish, [Java::java.lang.String.java_class,Java::java.lang.Object.java_class,Java::IoVertxCoreEventbus::DeliveryOptions.java_class]).call(address,::Vertx::Util::Utils.to_object(message),Java::IoVertxCoreEventbus::DeliveryOptions.new(::Vertx::Util::Utils.to_json_object(options)))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling publish(#{address},#{message},#{options})"
    end

### - (`::Vertx::MessageProducer`) publisher(address = nil, options = nil)

Like #publisher but specifying delivery options that will be used for configuring the delivery of the message.

Parameters:

- address (`String`) (defaults to: `nil`) —
  the address to publish it to
- options (`Hash`) (defaults to: `nil`) —
  the delivery options

Returns:

- (`::Vertx::MessageProducer`) —
  The publisher

Raises:

- (`ArgumentError`)

    133
    134
    135
    136
    137
    138
    139
    140
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 133

    def publisher(address=nil,options=nil)
      if address.class == String && !block_given? && options == nil
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:publisher, [Java::java.lang.String.java_class]).call(address),::Vertx::MessageProducer, nil)
      elsif address.class == String && options.class == Hash && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:publisher, [Java::java.lang.String.java_class,Java::IoVertxCoreEventbus::DeliveryOptions.java_class]).call(address,Java::IoVertxCoreEventbus::DeliveryOptions.new(::Vertx::Util::Utils.to_json_object(options))),::Vertx::MessageProducer, nil)
      end
      raise ArgumentError, "Invalid arguments when calling publisher(#{address},#{options})"
    end

### - (`::Vertx::EventBus`) remove_interceptor { ... }

Remove an interceptor

Yields:

- the interceptor

Returns:

- (`::Vertx::EventBus`) —
  a reference to this, so the API can be used fluently

Raises:

- (`ArgumentError`)

    153
    154
    155
    156
    157
    158
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 153

    def remove_interceptor
      if block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:removeInterceptor, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::SendContext)) })),::Vertx::EventBus)
      end
      raise ArgumentError, "Invalid arguments when calling remove_interceptor()"
    end

### - (`self`) send(address = nil, message = nil, options = nil) { ... }

Like #send but specifying a `replyHandler` that will be called if the recipient subsequently replies to the message.

Parameters:

- address (`String`) (defaults to: `nil`) —
  the address to send it to
- message (`Object`) (defaults to: `nil`) —
  the message, may be `null`
- options (`Hash`) (defaults to: `nil`) —
  delivery options

Yields:

- reply handler will be called when any reply from the recipient is received, may be `null`

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 60

    def send(address=nil,message=nil,options=nil)
      if address.class == String && ::Vertx::Util::unknown_type.accept?(message) && !block_given? && options == nil
        @j_del.java_method(:send, [Java::java.lang.String.java_class,Java::java.lang.Object.java_class]).call(address,::Vertx::Util::Utils.to_object(message))
        return self
      elsif address.class == String && ::Vertx::Util::unknown_type.accept?(message) && block_given? && options == nil
        @j_del.java_method(:send, [Java::java.lang.String.java_class,Java::java.lang.Object.java_class,Java::IoVertxCore::Handler.java_class]).call(address,::Vertx::Util::Utils.to_object(message),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::Message, nil) : nil) }))
        return self
      elsif address.class == String && ::Vertx::Util::unknown_type.accept?(message) && options.class == Hash && !block_given?
        @j_del.java_method(:send, [Java::java.lang.String.java_class,Java::java.lang.Object.java_class,Java::IoVertxCoreEventbus::DeliveryOptions.java_class]).call(address,::Vertx::Util::Utils.to_object(message),Java::IoVertxCoreEventbus::DeliveryOptions.new(::Vertx::Util::Utils.to_json_object(options)))
        return self
      elsif address.class == String && ::Vertx::Util::unknown_type.accept?(message) && options.class == Hash && block_given?
        @j_del.java_method(:send, [Java::java.lang.String.java_class,Java::java.lang.Object.java_class,Java::IoVertxCoreEventbus::DeliveryOptions.java_class,Java::IoVertxCore::Handler.java_class]).call(address,::Vertx::Util::Utils.to_object(message),Java::IoVertxCoreEventbus::DeliveryOptions.new(::Vertx::Util::Utils.to_json_object(options)),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::Vertx::Message, nil) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling send(#{address},#{message},#{options})"
    end

### - (`::Vertx::MessageProducer`) sender(address = nil, options = nil)

Like #sender but specifying delivery options that will be used for configuring the delivery of the message.

Parameters:

- address (`String`) (defaults to: `nil`) —
  the address to send it to
- options (`Hash`) (defaults to: `nil`) —
  the delivery options

Returns:

- (`::Vertx::MessageProducer`) —
  The sender

Raises:

- (`ArgumentError`)

    120
    121
    122
    123
    124
    125
    126
    127
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/event_bus.rb', line 120

    def sender(address=nil,options=nil)
      if address.class == String && !block_given? && options == nil
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:sender, [Java::java.lang.String.java_class]).call(address),::Vertx::MessageProducer, nil)
      elsif address.class == String && options.class == Hash && !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:sender, [Java::java.lang.String.java_class,Java::IoVertxCoreEventbus::DeliveryOptions.java_class]).call(address,Java::IoVertxCoreEventbus::DeliveryOptions.new(::Vertx::Util::Utils.to_json_object(options))),::Vertx::MessageProducer, nil)
      end
      raise ArgumentError, "Invalid arguments when calling sender(#{address},#{options})"
    end