proton-c/bindings/ruby/lib/event/event.rb - qpid-proton - Git at Google

 #--
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
 # regarding copyright ownership.  The ASF licenses this file
 # to you under the Apache License, Version 2.0 (the
 # "License"); you may not use this file except in compliance
 # with the License.  You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing,
 # software distributed under the License is distributed on an
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
 #++

 module Qpid::Proton

   module Event

     # @private
     def self.event_type(const_name, method_name = nil) # :nodoc:
       unless Cproton.const_defined?(const_name)
         raise RuntimeError.new("no such constant: #{const_name}")
       end

       const_value = Cproton.const_get(const_name)
       method_name = "on_#{const_name.to_s[3..-1]}".downcase if method_name.nil?

       EventType.new(const_value, method_name)
     end

     # Defined as a programming convenience. No even of this type will ever
     # be generated.
     NONE = event_type(:PN_EVENT_NONE)

     # A reactor has been started.
     REACTOR_INIT = event_type(:PN_REACTOR_INIT)
     # A reactor has no more events to process.
     REACTOR_QUIESCED = event_type(:PN_REACTOR_QUIESCED)
     # A reactor has been stopred.
     REACTOR_FINAL = event_type(:PN_REACTOR_FINAL)

     # A timer event has occurred.
     TIMER_TASK = event_type(:PN_TIMER_TASK)

     # A connection has been created. This is the first even that will ever
     # be issued for a connection.
     CONNECTION_INIT = event_type(:PN_CONNECTION_INIT)
     # A conneciton has been bound toa  transport.
     CONNECTION_BOUND = event_type(:PN_CONNECTION_BOUND)
     # A connection has been unbound from its transport.
     CONNECTION_UNBOUND = event_type(:PN_CONNECTION_UNBOUND)
     # A local connection endpoint has been opened.
     CONNECTION_LOCAL_OPEN = event_type(:PN_CONNECTION_LOCAL_OPEN)
     # A local connection endpoint has been closed.
     CONNECTION_LOCAL_CLOSE = event_type(:PN_CONNECTION_LOCAL_CLOSE)
     # A remote endpoint has opened its connection.
     CONNECTION_REMOTE_OPEN = event_type(:PN_CONNECTION_REMOTE_OPEN)
     # A remote endpoint has closed its connection.
     CONNECTION_REMOTE_CLOSE = event_type(:PN_CONNECTION_REMOTE_CLOSE)
     # A connection has been freed and any outstanding processing has been
     # completed. This is the final event htat will ever be issued for a
     # connection
     CONNECTION_FINAL = event_type(:PN_CONNECTION_FINAL)

     # A session has been created. This is the first event that will ever be
     # issues for a session.
     SESSION_INIT = event_type(:PN_SESSION_INIT)
     # A local session endpoint has been opened.
     SESSION_LOCAL_OPEN = event_type(:PN_SESSION_LOCAL_OPEN)
     # A local session endpoint has been closed.
     SESSION_LOCAL_CLOSE = event_type(:PN_SESSION_LOCAL_CLOSE)
     # A remote endpoint has opened its session.
     SESSION_REMOTE_OPEN = event_type(:PN_SESSION_REMOTE_OPEN)
     # A remote endpoint has closed its session.
     SESSION_REMOTE_CLOSE = event_type(:PN_SESSION_REMOTE_CLOSE)
     # A session has been freed and any outstanding processing has been
     # completed. This is the final event that will ever be issued for a
     # session
     SESSION_FINAL = event_type(:PN_SESSION_FINAL)

     # A link has been created. This is the first event that will ever be
     # issued for a link.
     LINK_INIT = event_type(:PN_LINK_INIT)
     # A local link endpoint has been opened.
     LINK_LOCAL_OPEN = event_type(:PN_LINK_LOCAL_OPEN)
     # A local link endpoint has been closed.
     LINK_LOCAL_CLOSE = event_type(:PN_LINK_LOCAL_CLOSE)
     # A local link endpoint has been detached.
     LINK_LOCAL_DETACH = event_type(:PN_LINK_LOCAL_DETACH)
     # A remote endpoint has opened its link.
     LINK_REMOTE_OPEN = event_type(:PN_LINK_REMOTE_OPEN)
     # A remote endpoint has closed its link.
     LINK_REMOTE_CLOSE = event_type(:PN_LINK_REMOTE_CLOSE)
     # A remote endpoint has detached its link.
     LINK_REMOTE_DETACH = event_type(:PN_LINK_REMOTE_DETACH)
     # The flow control state for a link has changed.
     LINK_FLOW = event_type(:PN_LINK_FLOW)
     # A link has been freed and any outstanding processing has been completed.
     # This is the final event htat will ever be issued for a link.
     LINK_FINAL = event_type(:PN_LINK_FINAL)

     # A delivery has been created or updated.
     DELIVERY = event_type(:PN_DELIVERY)

     # A transport has new data to read and/or write.
     TRANSPORT = event_type(:PN_TRANSPORT)
     # Indicates that a transport error has occurred.
     # @see Transport#condition To access the details of the error.
     TRANSPORT_ERROR = event_type(:PN_TRANSPORT_ERROR)
     # Indicates that the head of a transport has been closed. This means the
     # transport will never produce more bytes for output to the network.
     TRANSPORT_HEAD_CLOSED = event_type(:PN_TRANSPORT_HEAD_CLOSED)
     # Indicates that the trail of a transport has been closed. This means the
     # transport will never be able to process more bytes from the network.
     TRANSPORT_TAIL_CLOSED = event_type(:PN_TRANSPORT_TAIL_CLOSED)
     # Indicates that both the head and tail of a transport are closed.
     TRANSPORT_CLOSED = event_type(:PN_TRANSPORT_CLOSED)

     SELECTABLE_INIT = event_type(:PN_SELECTABLE_INIT)
     SELECTABLE_UPDATED = event_type(:PN_SELECTABLE_UPDATED)
     SELECTABLE_READABLE = event_type(:PN_SELECTABLE_READABLE)
     SELECTABLE_WRITABLE = event_type(:PN_SELECTABLE_WRITABLE)
     SELECTABLE_EXPIRED = event_type(:PN_SELECTABLE_EXPIRED)
     SELECTABLE_ERROR = event_type(:PN_SELECTABLE_ERROR)
     SELECTABLE_FINAL = event_type(:PN_SELECTABLE_FINAL)

     # An Event provides notification of a state change within the protocol
     # engine.
     #
     # Every event has a type that identifies what sort of state change has
     # occurred, along with a pointer to the object whose state has changed,
     # and also any associated objects.
     #
     # For more details on working with Event, please refer to Collector.
     #
     # @see Qpid::Proton::Event The list of predefined events.
     #
     class Event < EventBase

       # @private
       include Qpid::Proton::Util::ClassWrapper
       # @private
       include Qpid::Proton::Util::Wrapper

       # Creates a Ruby object for the given pn_event_t.
       #
       # @private
       def self.wrap(impl, number = nil)
         return nil if impl.nil?

         result = self.fetch_instance(impl, :pn_event_attachments)
         return result unless result.nil?
         number = Cproton.pn_event_type(impl) if number.nil?
         event = Event.new(impl, number)
         return event.context if event.context.is_a? EventBase
         return event
       end

       # @private
       def initialize(impl, number)
         @impl = impl
         class_name = Cproton.pn_class_name(Cproton.pn_event_class(impl))
         context = class_wrapper(class_name, Cproton.pn_event_context(impl))
         event_type = EventType.by_type(Cproton.pn_event_type(impl))
         super(class_name, context, event_type)
         @type = EventType.by_type(number)
         self.class.store_instance(self, :pn_event_attachments)
       end

       # Notifies the handler(s) of this event.
       #
       # If a handler responds to the event's method then that method is invoked
       # and passed the event. Otherwise, if the handler defines the
       # +on_unhandled+ method, then that will be invoked instead.
       #
       # If the handler defines a +handlers+ method then that will be invoked and
       # passed the event afterward.
       #
       # @example
       #
       #   class FallbackEventHandler
       #
       #     # since it now defines a handlers method, any event will iterate
       #     # through them and invoke the +dispatch+ method on each
       #     attr_accessor handlers
       #
       #     def initialize
       #       @handlers = []
       #     end
       #
       #     # invoked for any event not otherwise handled
       #     def on_unhandled(event)
       #       puts "Unable to invoke #{event.type.method} on #{event.context}."
       #     end
       #
       #   end
       #
       # @param handler [Object] An object which implements either the event's
       #    handler method or else responds to :handlers with an array of other
       #    handlers.
       #
       def dispatch(handler, type = nil)
         type = @type if type.nil?
         if handler.is_a?(Qpid::Proton::Handler::WrappedHandler)
           Cproton.pn_handler_dispatch(handler.impl, @impl, type.number)
         else
           result = Qpid::Proton::Event.dispatch(handler, type.method, self)
           if (result != "DELEGATED") && handler.respond_to?(:handlers)
             handler.handlers.each do |hndlr|
               self.dispatch(hndlr)
             end
           end
         end
       end

       # Returns the reactor for this event.
       #
       # @return [Reactor, nil] The reactor.
       #
       def reactor
         impl = Cproton.pn_event_reactor(@impl)
         Qpid::Proton::Util::ClassWrapper::WRAPPERS["pn_reactor"].call(impl)
       end

       def container
         impl = Cproton.pn_event_reactor(@impl)
         Qpid::Proton::Util::ClassWrapper::WRAPPERS["pn_reactor"].call(impl)
       end

       # Returns the transport for this event.
       #
       # @return [Transport, nil] The transport.
       #
       def transport
         Qpid::Proton::Transport.wrap(Cproton.pn_event_transport(@impl))
       end

       # Returns the Connection for this event.
       #
       # @return [Connection, nil] The connection.
       #
       def connection
         Qpid::Proton::Connection.wrap(Cproton.pn_event_connection(@impl))
       end

       # Returns the Session for this event.
       #
       # @return [Session, nil] The session
       #
       def session
         Qpid::Proton::Session.wrap(Cproton.pn_event_session(@impl))
       end

       # Returns the Link for this event.
       #
       # @return [Link, nil] The link.
       #
       def link
         Qpid::Proton::Link.wrap(Cproton.pn_event_link(@impl))
       end

       # Returns the Sender, or nil if there is no Link, associated  with this
       # event if that link is a sender.
       #
       # @return [Sender, nil] The sender.
       #
       def sender
         return self.link if !self.link.nil? && self.link.sender?
       end

       # Returns the Receiver, or nil if there is no Link, associated with this
       # event if that link is a receiver.
       #
       # @return [Receiver, nil] The receiver.
       #
       def receiver
         return self.link if !self.link.nil? && self.link.receiver?
       end

       # Returns the Delivery associated with this event.
       #
       # @return [Delivery, nil] The delivery.
       #
       def delivery
         Qpid::Proton::Delivery.wrap(Cproton.pn_event_delivery(@impl))
       end

       # Sets the message.
       #
       # @param message [Qpid::Proton::Message] The message
       #
       def message=(message)
         @message = message
       end

       # Returns the message.
       #
       # @return [Qpid::Proton::Message] The message.
       #
       def message
         @message
       end

       # @private
       def to_s
         "#{self.type}(#{self.context})"
       end

     end

   end

 end
	#--
	# Licensed to the Apache Software Foundation (ASF) under one
	# or more contributor license agreements. See the NOTICE file
	# distributed with this work for additional information
	# regarding copyright ownership. The ASF licenses this file
	# to you under the Apache License, Version 2.0 (the
	# "License"); you may not use this file except in compliance
	# with the License. You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing,
	# software distributed under the License is distributed on an
	# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	# KIND, either express or implied. See the License for the
	# specific language governing permissions and limitations
	# under the License.
	#++

	module Qpid::Proton

	module Event

	# @private
	def self.event_type(const_name, method_name = nil) # :nodoc:
	unless Cproton.const_defined?(const_name)
	raise RuntimeError.new("no such constant: #{const_name}")
	end

	const_value = Cproton.const_get(const_name)
	method_name = "on_#{const_name.to_s[3..-1]}".downcase if method_name.nil?

	EventType.new(const_value, method_name)
	end

	# Defined as a programming convenience. No even of this type will ever
	# be generated.
	NONE = event_type(:PN_EVENT_NONE)

	# A reactor has been started.
	REACTOR_INIT = event_type(:PN_REACTOR_INIT)
	# A reactor has no more events to process.
	REACTOR_QUIESCED = event_type(:PN_REACTOR_QUIESCED)
	# A reactor has been stopred.
	REACTOR_FINAL = event_type(:PN_REACTOR_FINAL)

	# A timer event has occurred.
	TIMER_TASK = event_type(:PN_TIMER_TASK)

	# A connection has been created. This is the first even that will ever
	# be issued for a connection.
	CONNECTION_INIT = event_type(:PN_CONNECTION_INIT)
	# A conneciton has been bound toa transport.
	CONNECTION_BOUND = event_type(:PN_CONNECTION_BOUND)
	# A connection has been unbound from its transport.
	CONNECTION_UNBOUND = event_type(:PN_CONNECTION_UNBOUND)
	# A local connection endpoint has been opened.
	CONNECTION_LOCAL_OPEN = event_type(:PN_CONNECTION_LOCAL_OPEN)
	# A local connection endpoint has been closed.
	CONNECTION_LOCAL_CLOSE = event_type(:PN_CONNECTION_LOCAL_CLOSE)
	# A remote endpoint has opened its connection.
	CONNECTION_REMOTE_OPEN = event_type(:PN_CONNECTION_REMOTE_OPEN)
	# A remote endpoint has closed its connection.
	CONNECTION_REMOTE_CLOSE = event_type(:PN_CONNECTION_REMOTE_CLOSE)
	# A connection has been freed and any outstanding processing has been
	# completed. This is the final event htat will ever be issued for a
	# connection
	CONNECTION_FINAL = event_type(:PN_CONNECTION_FINAL)

	# A session has been created. This is the first event that will ever be
	# issues for a session.
	SESSION_INIT = event_type(:PN_SESSION_INIT)
	# A local session endpoint has been opened.
	SESSION_LOCAL_OPEN = event_type(:PN_SESSION_LOCAL_OPEN)
	# A local session endpoint has been closed.
	SESSION_LOCAL_CLOSE = event_type(:PN_SESSION_LOCAL_CLOSE)
	# A remote endpoint has opened its session.
	SESSION_REMOTE_OPEN = event_type(:PN_SESSION_REMOTE_OPEN)
	# A remote endpoint has closed its session.
	SESSION_REMOTE_CLOSE = event_type(:PN_SESSION_REMOTE_CLOSE)
	# A session has been freed and any outstanding processing has been
	# completed. This is the final event that will ever be issued for a
	# session
	SESSION_FINAL = event_type(:PN_SESSION_FINAL)

	# A link has been created. This is the first event that will ever be
	# issued for a link.
	LINK_INIT = event_type(:PN_LINK_INIT)
	# A local link endpoint has been opened.
	LINK_LOCAL_OPEN = event_type(:PN_LINK_LOCAL_OPEN)
	# A local link endpoint has been closed.
	LINK_LOCAL_CLOSE = event_type(:PN_LINK_LOCAL_CLOSE)
	# A local link endpoint has been detached.
	LINK_LOCAL_DETACH = event_type(:PN_LINK_LOCAL_DETACH)
	# A remote endpoint has opened its link.
	LINK_REMOTE_OPEN = event_type(:PN_LINK_REMOTE_OPEN)
	# A remote endpoint has closed its link.
	LINK_REMOTE_CLOSE = event_type(:PN_LINK_REMOTE_CLOSE)
	# A remote endpoint has detached its link.
	LINK_REMOTE_DETACH = event_type(:PN_LINK_REMOTE_DETACH)
	# The flow control state for a link has changed.
	LINK_FLOW = event_type(:PN_LINK_FLOW)
	# A link has been freed and any outstanding processing has been completed.
	# This is the final event htat will ever be issued for a link.
	LINK_FINAL = event_type(:PN_LINK_FINAL)

	# A delivery has been created or updated.
	DELIVERY = event_type(:PN_DELIVERY)

	# A transport has new data to read and/or write.
	TRANSPORT = event_type(:PN_TRANSPORT)
	# Indicates that a transport error has occurred.
	# @see Transport#condition To access the details of the error.
	TRANSPORT_ERROR = event_type(:PN_TRANSPORT_ERROR)
	# Indicates that the head of a transport has been closed. This means the
	# transport will never produce more bytes for output to the network.
	TRANSPORT_HEAD_CLOSED = event_type(:PN_TRANSPORT_HEAD_CLOSED)
	# Indicates that the trail of a transport has been closed. This means the
	# transport will never be able to process more bytes from the network.
	TRANSPORT_TAIL_CLOSED = event_type(:PN_TRANSPORT_TAIL_CLOSED)
	# Indicates that both the head and tail of a transport are closed.
	TRANSPORT_CLOSED = event_type(:PN_TRANSPORT_CLOSED)

	SELECTABLE_INIT = event_type(:PN_SELECTABLE_INIT)
	SELECTABLE_UPDATED = event_type(:PN_SELECTABLE_UPDATED)
	SELECTABLE_READABLE = event_type(:PN_SELECTABLE_READABLE)
	SELECTABLE_WRITABLE = event_type(:PN_SELECTABLE_WRITABLE)
	SELECTABLE_EXPIRED = event_type(:PN_SELECTABLE_EXPIRED)
	SELECTABLE_ERROR = event_type(:PN_SELECTABLE_ERROR)
	SELECTABLE_FINAL = event_type(:PN_SELECTABLE_FINAL)

	# An Event provides notification of a state change within the protocol
	# engine.
	#
	# Every event has a type that identifies what sort of state change has
	# occurred, along with a pointer to the object whose state has changed,
	# and also any associated objects.
	#
	# For more details on working with Event, please refer to Collector.
	#
	# @see Qpid::Proton::Event The list of predefined events.
	#
	class Event < EventBase

	# @private
	include Qpid::Proton::Util::ClassWrapper
	# @private
	include Qpid::Proton::Util::Wrapper

	# Creates a Ruby object for the given pn_event_t.
	#
	# @private
	def self.wrap(impl, number = nil)
	return nil if impl.nil?

	result = self.fetch_instance(impl, :pn_event_attachments)
	return result unless result.nil?
	number = Cproton.pn_event_type(impl) if number.nil?
	event = Event.new(impl, number)
	return event.context if event.context.is_a? EventBase
	return event
	end

	# @private
	def initialize(impl, number)
	@impl = impl
	class_name = Cproton.pn_class_name(Cproton.pn_event_class(impl))
	context = class_wrapper(class_name, Cproton.pn_event_context(impl))
	event_type = EventType.by_type(Cproton.pn_event_type(impl))
	super(class_name, context, event_type)
	@type = EventType.by_type(number)
	self.class.store_instance(self, :pn_event_attachments)
	end

	# Notifies the handler(s) of this event.
	#
	# If a handler responds to the event's method then that method is invoked
	# and passed the event. Otherwise, if the handler defines the
	# +on_unhandled+ method, then that will be invoked instead.
	#
	# If the handler defines a +handlers+ method then that will be invoked and
	# passed the event afterward.
	#
	# @example
	#
	# class FallbackEventHandler
	#
	# # since it now defines a handlers method, any event will iterate
	# # through them and invoke the +dispatch+ method on each
	# attr_accessor handlers
	#
	# def initialize
	# @handlers = []
	# end
	#
	# # invoked for any event not otherwise handled
	# def on_unhandled(event)
	# puts "Unable to invoke #{event.type.method} on #{event.context}."
	# end
	#
	# end
	#
	# @param handler [Object] An object which implements either the event's
	# handler method or else responds to :handlers with an array of other
	# handlers.
	#
	def dispatch(handler, type = nil)
	type = @type if type.nil?
	if handler.is_a?(Qpid::Proton::Handler::WrappedHandler)
	Cproton.pn_handler_dispatch(handler.impl, @impl, type.number)
	else
	result = Qpid::Proton::Event.dispatch(handler, type.method, self)
	if (result != "DELEGATED") && handler.respond_to?(:handlers)
	handler.handlers.each do \|hndlr\|
	self.dispatch(hndlr)
	end
	end
	end
	end

	# Returns the reactor for this event.
	#
	# @return [Reactor, nil] The reactor.
	#
	def reactor
	impl = Cproton.pn_event_reactor(@impl)
	Qpid::Proton::Util::ClassWrapper::WRAPPERS["pn_reactor"].call(impl)
	end

	def container
	impl = Cproton.pn_event_reactor(@impl)
	Qpid::Proton::Util::ClassWrapper::WRAPPERS["pn_reactor"].call(impl)
	end

	# Returns the transport for this event.
	#
	# @return [Transport, nil] The transport.
	#
	def transport
	Qpid::Proton::Transport.wrap(Cproton.pn_event_transport(@impl))
	end

	# Returns the Connection for this event.
	#
	# @return [Connection, nil] The connection.
	#
	def connection
	Qpid::Proton::Connection.wrap(Cproton.pn_event_connection(@impl))
	end

	# Returns the Session for this event.
	#
	# @return [Session, nil] The session
	#
	def session
	Qpid::Proton::Session.wrap(Cproton.pn_event_session(@impl))
	end

	# Returns the Link for this event.
	#
	# @return [Link, nil] The link.
	#
	def link
	Qpid::Proton::Link.wrap(Cproton.pn_event_link(@impl))
	end

	# Returns the Sender, or nil if there is no Link, associated with this
	# event if that link is a sender.
	#
	# @return [Sender, nil] The sender.
	#
	def sender
	return self.link if !self.link.nil? && self.link.sender?
	end

	# Returns the Receiver, or nil if there is no Link, associated with this
	# event if that link is a receiver.
	#
	# @return [Receiver, nil] The receiver.
	#
	def receiver
	return self.link if !self.link.nil? && self.link.receiver?
	end

	# Returns the Delivery associated with this event.
	#
	# @return [Delivery, nil] The delivery.
	#
	def delivery
	Qpid::Proton::Delivery.wrap(Cproton.pn_event_delivery(@impl))
	end

	# Sets the message.
	#
	# @param message [Qpid::Proton::Message] The message
	#
	def message=(message)
	@message = message
	end

	# Returns the message.
	#
	# @return [Qpid::Proton::Message] The message.
	#
	def message
	@message
	end

	# @private
	def to_s
	"#{self.type}(#{self.context})"
	end

	end

	end

	end