Class: Qpid::Proton::Event::Collector

Inherits:
Object
  • Object
show all
Defined in:
lib/event/collector.rb

Overview

A Collector is used to register interest in events produced by one or more Connection objects.

Events

Examples:


conn = Qpid::Proton::Connection.new
coll = Qpid::Proton::Event::Collector.new
conn.collect(coll)

# transport setup not included here for brevity

loop do

   # wait for an event and then perform the following

   event = collector.peek

   unless event.nil?
     case event.type

     when Qpid::Proton::Event::CONNECTION_REMOTE_CLOSE
       conn = event.context # the context here is the connection
       # the remote connection closed, so only close our side if it's
       # still open
       if !(conn.state & Qpid::Proton::Endpoint::LOCAL_CLOSED)
         conn.close
       end

     when Qpid::proton::Event::SESSION_REMOTE_OPEN
       session = event.session # the context here is the session
       # the remote session is now open, so if the local session is
       # uninitialized, then open it
       if session.state & Qpid::Proton::Endpoint::LOCAL_UNINIT
         session.incoming_capacity = 1000000
         session.open
       end

     end

    # remove the processed event and get the next event
    # the loop will exit when we have no more events to process
    collector.pop
    event = collector.peek

end

See Also:

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Collector

Creates a new Collector.



79
80
81
82
 
# File 'lib/event/collector.rb', line 79

def initialize
  @impl = Cproton.pn_collector
  ObjectSpace.define_finalizer(self, self.class.finalize!(@impl))
end

Instance Method Details

#peek ⇒ Event?

Access the head event.

This operation will continue to return the same event until it is cleared by using #pop. The pointer return by this operation will be valid until ::pn_collector_pop is invoked or #free is called, whichever happens sooner.

Returns:

  • (Event) —

    the head event

  • (nil) —

    if there are no events

See Also:



131
132
133
 
# File 'lib/event/collector.rb', line 131

def peek
  Event.wrap(Cproton.pn_collector_peek(@impl))
end

#pop ⇒ Boolean

Clear the head event.

Returns:

  • (Boolean) —

    true if an event was removed

See Also:



142
143
144
 
# File 'lib/event/collector.rb', line 142

def pop
  Cproton.pn_collector_pop(@impl)
end

#put(context, event_type) ⇒ Event?

Place a new event on the collector.

This operation will create a new event of the given type and context and return a new Event instance. In some cases an event of a given type can be elided. When this happens, this operation will return nil.

Parameters:

  • context (Object) —

    The event context.

  • event_type (EventType) —

    The event type.

Returns:

  • (Event) —

    the event if it was queued

  • (nil) —

    if it was elided



114
115
116
 
# File 'lib/event/collector.rb', line 114

def put(context, event_type)
  Cproton.pn_collector_put(@impl, Cproton.pn_rb2void(context), event_type.type_code)
end

#release ⇒ Object

Releases the collector.

Once in a released state, a collector will drain any internally queued events, shrink its memory footprint to a minimu, and discard any newly created events.



97
98
99
 
# File 'lib/event/collector.rb', line 97

def release
  Cproton.pn_collector_release(@impl)
end