blob: d75cfffbb517cd5e047128587d49e7b92984d1ee [file] [log] [blame]
# 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
# @deprecated Only used with the deprecated {Handler::MessagingHandler} API.
class Event
private
include Util::Deprecation
PROTON_METHOD_PREFIX = "pn_disposition"
include Util::Wrapper
EVENT_TYPE_NAMES = [:PN_EVENT_NONE,
:PN_CONNECTION_INIT,
:PN_CONNECTION_BOUND,
:PN_CONNECTION_UNBOUND,
:PN_CONNECTION_LOCAL_OPEN,
:PN_CONNECTION_REMOTE_OPEN,
:PN_CONNECTION_LOCAL_CLOSE,
:PN_CONNECTION_REMOTE_CLOSE,
:PN_CONNECTION_FINAL,
:PN_SESSION_INIT,
:PN_SESSION_LOCAL_OPEN,
:PN_SESSION_REMOTE_OPEN,
:PN_SESSION_LOCAL_CLOSE,
:PN_SESSION_REMOTE_CLOSE,
:PN_SESSION_FINAL,
:PN_LINK_INIT,
:PN_LINK_LOCAL_OPEN,
:PN_LINK_REMOTE_OPEN,
:PN_LINK_LOCAL_CLOSE,
:PN_LINK_REMOTE_CLOSE,
:PN_LINK_LOCAL_DETACH,
:PN_LINK_REMOTE_DETACH,
:PN_LINK_FLOW,
:PN_LINK_FINAL,
:PN_DELIVERY,
:PN_TRANSPORT,
:PN_TRANSPORT_AUTHENTICATED,
:PN_TRANSPORT_ERROR,
:PN_TRANSPORT_HEAD_CLOSED,
:PN_TRANSPORT_TAIL_CLOSED,
:PN_TRANSPORT_CLOSED]
TYPE_METHODS = EVENT_TYPE_NAMES.each_with_object({}) do |n, h|
type = Cproton.const_get(n)
h[type] = "on_#{Cproton.pn_event_type_name(type)[3..-1]}".downcase.to_sym
end
# Use Event.new(impl) to wrap a C event, or Event.new(nil, method, context)
# to create a pure-ruby event.
def initialize(impl, method=nil, context=nil)
@impl, @method, @context = impl, method, context
@method ||= TYPE_METHODS[Cproton.pn_event_type(@impl)] if @impl
end
# Get the context if it is_a?(clazz), else call method on the context
def get(clazz, method=nil)
(ctx = context).is_a?(clazz) ? ctx : ctx.__send__(method) rescue nil
end
def _context
x = Cproton.pn_event_context(@impl)
case Cproton.pn_class_id(Cproton.pn_event_class(@impl))
when Cproton::CID_pn_transport then Transport.wrap(Cproton.pn_cast_pn_transport(x))
when Cproton::CID_pn_connection then Connection.wrap(Cproton.pn_cast_pn_connection(x))
when Cproton::CID_pn_session then Session.wrap(Cproton.pn_cast_pn_session(x))
when Cproton::CID_pn_link then Link.wrap(Cproton.pn_cast_pn_link(x))
when Cproton::CID_pn_delivery then Delivery.wrap(Cproton.pn_cast_pn_delivery(x))
end
end
public
# Call handler.{#method}(self) if handler.respond_to? {#method}
# @return [Boolean] true if handler responded to the method, nil if not.
def dispatch(handler)
(handler.__send__(@method, self); true) if handler.respond_to? @method
end
# @return [Symbol] method name that this event will call in {#dispatch}
attr_accessor :method
alias type method
# @return [Object] the event context object
def context; return @context ||= _context; end
# @return [Container, nil] container for this event
def container() @container ||= get(Container, :container); end
# @return [Transport, nil] transport for this event
def transport() @transport ||= get(Transport, :transport); end
# @return [Connection, nil] the connection for this event
def connection() @connection ||= get(Connection, :connection); end
# @return [Session, nil] session for this event
def session() @session ||= get(Session, :session); end
# @return [Link, nil] link for this event
def link() @link ||= get(Link, :link); end
# @return [Sender, nil] sender associated with this event
def sender() link if link && link.sender?; end
# @return [Receiver, nil] receiver associated with this event
def receiver() link if link && link.receiver?; end
# @return [Delivery, nil] delivery for this event
def delivery()
@delivery ||= case context
when Delivery then @delivery = @context
# deprecated: for backwards compat allow a Tracker to be treated as a Delivery
when Tracker then @delivery = Delivery.new(context.impl)
end
end
# @return [Tracker, nil] delivery for this event
def tracker() @tracker ||= get(Tracker); end
# @return [Message, nil] message for this event
def message() @message ||= delivery.message if delivery; end
def to_s() "#{self.class}(#{method}, #{context})"; end
def inspect() "#{self.class}(#{method.inspect}, #{context.inspect})"; end
# @return [Condition] Error condition associated with this event or nil if none.
def condition
(context.remote_condition if context.respond_to? :remote_condition) ||
(context.condition if context.respond_to? :condition)
end
# @deprecated use {#container}
deprecated_alias :reactor, :container
# @private
Event = self
end
end