<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Spring.Messaging.Ems</name>
    </assembly>
    <members>
        <member name="T:Spring.Messaging.Ems.Common.EmsConnection">
            <summary>
            A Connection object is a client's active connection to TIBCO EMS Server. 
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Common.IConnection">
            <summary>
            An interface containing all methods and properties on the TIBCO.EMS.Connection class.
            Refer to the TIBCO EMS API documentation for more information.
            </summary>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.IConnection.Close">
            <summary>
            Closes the connection and reclaims resources. 
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.IConnection.CreateSession(System.Boolean,System.Int32)">
            <summary>
            Creates the session.
            </summary>
            <param name="transacted">if set to <c>true</c> the session has transaction semantcis.</param>
            <param name="acknowledgeMode">Indicates whether and how the consumer is to acknowledge received messages.
            This version of CreateSession accepts an integer value associated with the acknowledge mode described by a Session member and should only be used for backward compatibility.
            This parameter is ignored if the session is transacted.</param>
            <returns>A newly created session.</returns>         
        </member>
        <member name="M:Spring.Messaging.Ems.Common.IConnection.CreateSession(System.Boolean,TIBCO.EMS.SessionMode)">
            <summary>
            Creates the session.
            </summary>
            <param name="transacted">if set to <c>true</c> [transacted].</param>
            <param name="acknowledgeMode">The acknowledge mode.
            When true, the new session has transaction semantics.
            Indicates whether and how the consumer is to acknowledge received messages. 
            Legal values are listed under SessionMode. 
            This parameter is ignored if the session is transacted. 
            </param>
            <returns>A newly created session.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.IConnection.Start">
            <summary>
            Starts (or restarts) a connection's delivery of incoming messages. 
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.IConnection.Stop">
            <summary>
            Temporarily stops a connection's delivery of incoming messages. 
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.IConnection.ToString">
            <summary>
            A String representation of the connection object 
            </summary>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnection.NativeConnection">
            <summary>
            Gets the native TIBCO EMS connection.
            </summary>
            <value>The native connection.</value>
        </member>
        <member name="E:Spring.Messaging.Ems.Common.IConnection.EMSExceptionHandler">
            <summary>
            Occurs when the client library detects a problem with the connection.
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnection.ActiveURL">
            <summary>
            Gets the URL of the server this connection is currently connected to
            </summary>
            <value>The active URL.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnection.ClientID">
            <summary>
            Gets or sets the client ID.
            </summary>
            <value>The client ID.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnection.ConnID">
            <summary>
            Gets the connection ID.
            </summary>
            <value>The connection ID.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnection.ExceptionListener">
            <summary>
            Gets or sets the exception listener.
            </summary>
            <value>The exception listener.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnection.IsClosed">
            <summary>
            Gets a value indicating whether the connection is closed.
            </summary>
            <value><c>true</c> if the connection is closed; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnection.IsSecure">
            <summary>        
            Gets a value indicating whether the connection communicates with a secure protocol
            </summary>
            <value><c>true</c> if the connection communicates with a secure protocol; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnection.MetaData">
            <summary>
            Gets the metadata for this connection
            </summary>
            <value>The metadata for this connection.</value>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.EmsConnection.#ctor(TIBCO.EMS.Connection)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Common.EmsConnection"/> class.
            </summary>
            <param name="connection">The underlying TIBCO EMS connection.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.EmsConnection.Close">
            <summary>
            Closes the connection and reclaims resources.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.EmsConnection.CreateSession(System.Boolean,System.Int32)">
            <summary>
            Creates the session.
            </summary>
            <param name="transacted">if set to <c>true</c> the session has transaction semantcis.</param>
            <param name="acknowledgeMode">Indicates whether and how the consumer is to acknowledge received messages.
            This version of CreateSession accepts an integer value associated with the acknowledge mode described by a Session member and should only be used for backward compatibility.
            This parameter is ignored if the session is transacted.</param>
            <returns>A newly created session.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.EmsConnection.CreateSession(System.Boolean,TIBCO.EMS.SessionMode)">
            <summary>
            Creates the session.
            </summary>
            <param name="transacted">if set to <c>true</c> [transacted].</param>
            <param name="acknowledgeMode">The acknowledge mode.
            When true, the new session has transaction semantics.
            Indicates whether and how the consumer is to acknowledge received messages.
            Legal values are listed under SessionMode.
            This parameter is ignored if the session is transacted.</param>
            <returns>A newly created session.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.EmsConnection.Start">
            <summary>
            Starts (or restarts) a connection's delivery of incoming messages.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.EmsConnection.Stop">
            <summary>
            Temporarily stops a connection's delivery of incoming messages.
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.EmsConnection.NativeConnection">
            <summary>
            Gets the native TIBCO EMS connection.
            </summary>
            <value>The native connection.</value>
        </member>
        <member name="E:Spring.Messaging.Ems.Common.EmsConnection.EMSExceptionHandler">
            <summary>
            Occurs when the client library detects a problem with the connection.
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.EmsConnection.ActiveURL">
            <summary>
            Gets the URL of the server this connection is currently connected to
            </summary>
            <value>The active URL.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.EmsConnection.ClientID">
            <summary>
            Gets or sets the client ID.
            </summary>
            <value>The client ID.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.EmsConnection.ConnID">
            <summary>
            Gets the connection ID.
            </summary>
            <value>The connection ID.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.EmsConnection.ExceptionListener">
            <summary>
            Gets or sets the exception listener.
            </summary>
            <value>The exception listener.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.EmsConnection.IsClosed">
            <summary>
            Gets a value indicating whether the connection is closed.
            </summary>
            <value>
            	<c>true</c> if the connection is closed; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.EmsConnection.IsSecure">
            <summary>
            Gets a value indicating whether the connection communicates with a secure protocol
            </summary>
            <value>
            	<c>true</c> if the connection communicates with a secure protocol; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.EmsConnection.MetaData">
            <summary>
            Gets the metadata for this connection
            </summary>
            <value>The metadata for this connection.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Common.IConnectionFactory">
            <summary>
            An interface containing all methods and properties on the TIBCO.EMS.ConnectionFactory class.    
            Refer to the TIBCO EMS API documentation for more information.
            </summary>
            <remarks>
            All the 'GetXXX()' methods in the TIBCO.EMS.ConnectionFactory were translated to .NET properties
            </remarks>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.IConnectionFactory.CreateConnection">
            <summary>
            Creates the connection.
            </summary>
            <returns>The newly created connection</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Common.IConnectionFactory.CreateConnection(System.String,System.String)">
            <summary>
            Creates the connection with the given username and password
            </summary>
            <param name="userName">Name of the user.</param>
            <param name="password">The password.</param>
            <returns></returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.NativeConnectionFactory">
            <summary>
            Gets the native TIBCO EMS connection factory.
            </summary>
            <value>The native connection factory.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.CertificateStore">
            <summary>
            Gets the certificate store info object associated with this connection factory. 
            </summary>
            <value>The certificate store.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.SSLProxyHost">
            <summary>
            Gets or sets the SSL proxy host.
            </summary>
            <value>The SSL proxy host.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.SSLProxyPort">
            <summary>
            Gets or sets the SSL proxy port.
            </summary>
            <value>The SSL proxy port.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.SSLProxyPassword">
            <summary>
            Gets the SSL proxy password.
            </summary>
            <value>The SSL proxy password.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.SSLProxyUser">
            <summary>
            Gets the SSL proxy user.
            </summary>
            <value>The SSL proxy user.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.CertificateStoreType">
            <summary>
            Sets the type of the certificate store.
            </summary>
            <value>The type of the certificate store.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.ClientID">
            <summary>
            Sets the client ID.
            </summary>
            <value>The client ID.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.ClientTracer">
            <summary>
            Sets the client tracer to a given output stream
            </summary>
            <value>The client tracer.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.ConnAttemptCount">
            <summary>
            Sets the number of connection attempts
            </summary>
            <value>The number of connection attempts.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.ConnAttemptDelay">
            <summary>
            Sets delay between connection attempts 
            </summary>
            <value>The delay between connection attempts.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.ConnAttemptTimeout">
            <summary>
            Sets the connection attempt timeout.
            </summary>
            <value>The connection attempt timeout.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.HostNameVerifier">
            <summary>
            Sets the custom host name verifier. Set to null to remove custom host name verifier. 
            </summary>
            <value>The host name verifier.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.MetricAsInt">
            <summary>
            Sets the load balance metric as an integer.
            </summary>
            <value>The load balance metric as int.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.MulticastDaemon">
            <summary>
            Sets the port on which the client will connect to the multicast daemon.
            </summary>
            <value>The multicast daemon port.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IConnectionFactory.MulticastEnabled">
            <summary>
            Sets whether MessageConsumers subscribed to a multicast-enabled topic will receive messages over multicast.
            </summary>
            <value><c>true</c> to enable multicast; <c>false</c> to disable.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Common.IMessageProducer.TimeToLive">
            <summary>
            Gets or sets the the default length of time in milliseconds from its dispatch time
            that a produced message should be retained by the message system.
            </summary>
            <remarks>Time to live is set to zero by default.</remarks>
            <value>The message time to live in milliseconds; zero is unlimited</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Common.IEmsSSLStoreType">
            <summary>
            Market interface for EMS SSL store types
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Config.EmsNamespaceParser">
            <summary>
            Namespace parser for the EMS namespace.
            </summary>
            <author>Mark Fisher</author>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Config.EmsNamespaceParser.Init">
            <summary>
            Register a MessageListenerContainer for the '<code>listener-container</code>' tag.
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Config.MessageListenerContainerObjectDefinitionParser">
            <summary>
            Parser for the EMS <code>&lt;listener-container&gt;</code> element.
            </summary>
            <author>Mark Fisher</author>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Config.MessageListenerContainerObjectDefinitionParser.ParseElement(System.Xml.XmlElement,Spring.Objects.Factory.Xml.ParserContext)">
            <summary>
            Parse the specified XmlElement and register the resulting
            ObjectDefinitions with the <see cref="P:Spring.Objects.Factory.Xml.ParserContext.Registry"/> IObjectDefinitionRegistry
            embedded in the supplied <see cref="T:Spring.Objects.Factory.Xml.ParserContext"/>
            </summary>
            <param name="element">The element to be parsed.</param>
            <param name="parserContext">TThe object encapsulating the current state of the parsing process.
            Provides access to a IObjectDefinitionRegistry</param>
            <returns>The primary object definition.</returns>
            <remarks>
            	<p>
            This method is never invoked if the parser is namespace aware
            and was called to process the root node.
            </p>
            </remarks>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.CachedMessageConsumer">
            <summary>
            EMS MessageConsumer decorator that adapts all calls
            to a shared MessageConsumer instance underneath.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET) </author>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageConsumer.#ctor(Spring.Messaging.Ems.Common.IMessageConsumer)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.CachedMessageConsumer"/> class.
            </summary>
            <param name="target">The target.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageConsumer.Receive">
            <summary>
            Receives the next message produced for this message consumer.
            </summary>
            <returns>the next message produced for this message consumer, , or null if this message consumer is concurrently closed</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageConsumer.Receive(System.Int64)">
            <summary>
            Receives the next message that arrives within the specified timeout interval.
            </summary>
            <param name="timeout">The timeout value.</param>
            <returns>the next message produced for this message consumer, or null if the timeout expires or this message consumer is concurrently closed</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageConsumer.ReceiveNoWait">
            <summary>
            Receives the next message if one is immediately available.
            </summary>
            <returns>the next message produced for this message consumer, or null if one is not available</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageConsumer.Close">
            <summary>
            No-op implementation since it is caching.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageConsumer.ToString">
            <summary>
            Description that shows this is a cached MessageConsumer
            </summary>
            <returns>Description that shows this is a cached MessageConsumer</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedMessageConsumer.Target">
            <summary>
            Gets the target MessageConsumer, the consumer we are 'wrapping'
            </summary>
            <value>The target MessageConsumer.</value>
        </member>
        <member name="E:Spring.Messaging.Ems.Connections.CachedMessageConsumer.MessageHandler">
            <summary>
            Occurs when a message is received.
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.CachedMessageProducer">
            <summary>
            MessageProducer decorator that adapts calls to a shared MessageProducer
            instance underneath, managing QoS settings locally within the decorator.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageProducer.#ctor(Spring.Messaging.Ems.Common.IMessageProducer)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.CachedMessageProducer"/> class.
            </summary>
            <param name="target">The target.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageProducer.Send(TIBCO.EMS.Message)">
            <summary>
            Sends the specified message.
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageProducer.Send(TIBCO.EMS.Message,System.Int32,System.Int32,System.Int64)">
            <summary>
            Sends the specified message.
            </summary>
            <param name="message">The message.</param>
            <param name="deliveryMode">The delivery mode.</param>
            <param name="priority">The priority.</param>
            <param name="timeToLive">The time to live.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageProducer.Send(TIBCO.EMS.Destination,TIBCO.EMS.Message)">
            <summary>
            Sends a message to the specified destination.
            </summary>
            <param name="destination">The destination.</param>
            <param name="message">The message.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageProducer.Close">
            <summary>
            Reset properties.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedMessageProducer.ToString">
            <summary>
            Returns string indicated this is a wrapped MessageProducer
            </summary>
            <returns></returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedMessageProducer.DisableMessageID">
            <summary>
            Gets or sets a value indicating whether disable setting of the message ID property.
            </summary>
            <value><c>true</c> if disable message ID setting; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedMessageProducer.DisableMessageTimestamp">
            <summary>
            Gets or sets a value indicating whether disable setting the message timestamp property.
            </summary>
            <value>
            	<c>true</c> if disable message timestamp; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedMessageProducer.DeliveryMode">
            <summary>
            Gets or sets the producer's default delivery mode.
            </summary>
            <value>The message delivery mode for this message producer</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedMessageProducer.MsgDeliveryMode">
            <summary>
            Gets or sets the MSG delivery mode.
            </summary>
            <value>The MSG delivery mode.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedMessageProducer.Priority">
            <summary>
            Gets or sets the priority of messages sent with this producer.
            </summary>
            <value>The priority.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedMessageProducer.TimeToLive">
            <summary>
            Gets or sets the the default length of time in milliseconds from its dispatch time
            that a produced message should be retained by the message system.
            </summary>
            <remarks>Time to live is set to zero by default.</remarks>
            <value>The message time to live in milliseconds; zero is unlimited</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedMessageProducer.Target">
            <summary>
            Gets the target MessageProducer, the producer we are 'wrapping'
            </summary>
            <value>The target MessageProducer.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.CachedSession">
            <summary>
            Wrapper for Session that caches producers and registers itself as available
            to the session cache when being closed.  Generally used for testing purposes or
            if need to get at the wrapped Session object via the TargetSession property (for
            vendor specific methods).
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack</author>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.IDecoratorSession">
            <summary>
            Subinterface of Session to be implemented by
            implementations that wrap an Session to provide added 
            functionality. Allows access to the the underlying target Session.
            </summary>
            <author>Mark Pollack</author>
            <see cref="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.GetTargetSession(Spring.Messaging.Ems.Common.ISession)"/>
            <see cref="T:Spring.Messaging.Ems.Connections.CachingConnectionFactory"/>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.IDecoratorSession.TargetSession">
            <summary>
            Gets the target session of the decorator.
            This will typically be the native provider Session or a wrapper from a session pool.
            </summary>
            <value>The underlying session, never null</value>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.#ctor(Spring.Messaging.Ems.Common.ISession,Spring.Collections.LinkedList,Spring.Messaging.Ems.Connections.CachingConnectionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.CachedSession"/> class.
            </summary>
            <param name="targetSession">The target session.</param>
            <param name="sessionList">The session list.</param>
            <param name="ccf">The CachingConnectionFactory.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateProducer(TIBCO.EMS.Destination)">
            <summary>
            Creates the producer, potentially returning a cached instance.
            </summary>
            <param name="destination">The destination.</param>
            <returns>A message producer.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.Close">
            <summary>
            If have not yet reached session cache size, cache the session, otherwise
            dispose of all cached message producers and close the session.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateConsumer(TIBCO.EMS.Destination)">
            <summary>
            Creates the consumer, potentially returning a cached instance. 
            </summary>
            <param name="destination">The destination.</param>
            <returns>A message consumer</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateConsumer(TIBCO.EMS.Destination,System.String)">
            <summary>
            Creates the consumer, potentially returning a cached instance. 
            </summary>
            <param name="destination">The destination.</param>
            <param name="selector">The selector.</param>
            <returns>A message consumer</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateConsumer(TIBCO.EMS.Destination,System.String,System.Boolean)">
            <summary>
            Creates the consumer, potentially returning a cached instance.
            </summary>
            <param name="destination">The destination.</param>
            <param name="selector">The selector.</param>
            <param name="noLocal">if set to <c>true</c> [no local].</param>
            <returns>A message consumer.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateDurableSubscriber(TIBCO.EMS.Topic,System.String,System.String,System.Boolean)">
            <summary>
            Creates the durable consumer, potentially returning a cached instance.
            </summary>
            <param name="destination">The destination.</param>
            <param name="subscription">The name of the durable subscription.</param>
            <param name="selector">The selector.</param>
            <param name="noLocal">if set to <c>true</c> [no local].</param>
            <returns>A message consumer</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateDurableSubscriber(TIBCO.EMS.Topic,System.String)">
            <summary>
            Creates the durable consumer, potentially returning a cached instance.
            </summary>
            <param name="destination">The destination.</param>
            <param name="subscription">The name of the durable subscription.</param>
            <returns>A message consumer</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateConsumer(TIBCO.EMS.Destination,System.String,System.Boolean,System.String)">
            <summary>
            Creates the consumer.
            </summary>
            <param name="destination">The destination.</param>
            <param name="selector">The selector.</param>
            <param name="noLocal">if set to <c>true</c> [no local].</param>
            <param name="subscription">The subscription.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateQueue(System.String)">
            <summary>
            Gets the queue.
            </summary>
            <param name="name">The name.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateTopic(System.String)">
            <summary>
            Gets the topic.
            </summary>
            <param name="name">The name.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateTemporaryQueue">
            <summary>
            Creates the temporary queue.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateTemporaryTopic">
            <summary>
            Creates the temporary topic.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateMessage">
            <summary>
            Creates the message.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateTextMessage">
            <summary>
            Creates the text message.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateTextMessage(System.String)">
            <summary>
            Creates the text message.
            </summary>
            <param name="text">The text.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateMapMessage">
            <summary>
            Creates the map message.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateBytesMessage">
            <summary>
            Creates the bytes message.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateObjectMessage">
            <summary>
            Creates the object message.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateObjectMessage(System.Object)">
            <summary>
            Creates the object message.
            </summary>
            <param name="body">The body.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.CreateStreamMessage">
            <summary>
            Creates the stream message.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.Commit">
            <summary>
            Commits this instance.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.Rollback">
            <summary>
            Rollbacks this instance.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachedSession.ToString">
            <summary>
            Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
            </summary>
            <returns>
            A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
            </returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedSession.TargetSession">
            <summary>
            Gets the target, for testing purposes.
            </summary>
            <value>The target.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedSession.Transacted">
            <summary>
            Gets a value indicating whether this <see cref="T:Spring.Messaging.Ems.Connections.CachedSession"/> is transacted.
            </summary>
            <value><c>true</c> if transacted; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachedSession.SessionAcknowledgeMode">
            <summary>
            Gets the acknowledgement mode.
            </summary>
            <value>The acknowledgement mode.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.CachingConnectionFactory">
            <summary>
            <see cref="T:Spring.Messaging.Ems.Connections.SingleConnectionFactory"/> subclass that adds
            Session, MessageProducer, and MessageConsumer caching.  This ConnectionFactory
            also switches the ReconnectOnException property to true
            by default, allowing for automatic recovery of the underlying
            Connection.
            </summary>
            <remarks>
            By default, only one single Session will be cached, with further requested
            Sessions being created and disposed on demand. Consider raising the
            SessionCacheSize property in case of a high-concurrency environment.
            <para>
            NOTE: This ConnectionFactory requires explicit closing of all Sessions
            obtained from its shared Connection. This is the usual recommendation for
            native EMS access code anyway. However, with this ConnectionFactory, its use
            is mandatory in order to actually allow for Session reuse.
            </para>
            <para>
            Note also that MessageConsumers obtained from a cached Session won't get
            closed until the Session will eventually be removed from the pool. This may
            lead to semantic side effects in some cases. For a durable subscriber, the
            logical <code>Session.Close()</code> call will also close the subscription.
            Re-registering a durable consumer for the same subscription on the same
            Session handle is not supported; close and reobtain a cached Session first.
            </para>
            </remarks>
            
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.SingleConnectionFactory">
            <summary>
            A ConnectionFactory adapter that returns the same Connection
            from all CreateConnection() calls, and ignores calls to
            Connection.Close().  According to the JMS Connection
            model, this is perfectly thread-safe. The 
            shared Connection can be automatically recovered in case of an Exception.
            </summary>
            <remarks>
            <para>
            You can either pass in a specific Connection directly or let this
            factory lazily create a Connection via a given target ConnectionFactory.
            </para>
            <para>
            Useful for testing and in applications when you want to keep using the
            same Connection for multiple <see cref="T:Spring.Messaging.Ems.Core.EmsTemplate"/>
            calls, without having a pooling ConnectionFactory underneath. This may span
            any number of transactions, even concurrently executing transactions.
            </para>
            <para>
            Note that Spring's message listener containers support the use of
            a shared Connection within each listener container instance. Using
            SingleConnectionFactory with a MessageListenerContainer only really makes sense for
            sharing a single Connection across multiple listener containers.
            </para>
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Messaging.Ems.Connections.SingleConnectionFactory.target">
            <summary>
            Wrapped Connection
            </summary>
        </member>
        <member name="F:Spring.Messaging.Ems.Connections.SingleConnectionFactory.connection">
            <summary>
            Proxy Connection
            </summary>
        </member>
        <member name="F:Spring.Messaging.Ems.Connections.SingleConnectionFactory.started">
            <summary>
            Whether the shared Connection has been started 
            </summary>
        </member>
        <member name="F:Spring.Messaging.Ems.Connections.SingleConnectionFactory.connectionMonitor">
            <summary>
            Synchronization monitor for the shared Connection
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.SingleConnectionFactory"/> class.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.#ctor(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.SingleConnectionFactory"/> class
            that alwasy returns the given Connection.
            </summary>
            <param name="target">The single Connection.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.#ctor(Spring.Messaging.Ems.Common.IConnectionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.SingleConnectionFactory"/> class
            that alwasy returns a single Connection.
            </summary>
            <param name="targetConnectionFactory">The target connection factory.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.CreateConnection">
            <summary>
            Creates the connection.
            </summary>
            <returns>A single shared connection</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.CreateConnection(System.String,System.String)">
            <summary>
            Creates the connection.
            </summary>
            <param name="userName">Name of the user.</param>
            <param name="password">The password.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.InitConnection">
            <summary>
            Initialize the underlying shared Connection. Closes and reinitializes the Connection if an underlying
            Connection is present already.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.OnException(TIBCO.EMS.EMSException)">
            <summary>
            Exception listener callback that renews the underlying single Connection.
            </summary>
            <param name="exception">The exception from the messaging infrastructure.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.PrepareConnection(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Prepares the connection before it is exposed.
            The default implementation applies ExceptionListener and client id.
            Can be overridden in subclasses.
            </summary>
            <param name="con">The Connection to prepare.</param>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by any EMS API methods.</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.GetSession(Spring.Messaging.Ems.Common.IConnection,TIBCO.EMS.SessionMode)">
            <summary>
            Template method for obtaining a (potentially cached) Session.
            </summary>
            <param name="con">The connection to operate on.</param>
            <param name="mode">The session ack mode.</param>
            <returns>the Session to use, or <code>null</code> to indicate
            creation of a raw standard Session</returns>  
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.DoCreateConnection">
            <summary>
            reate a JMS Connection via this template's ConnectionFactory.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.CloseConnection(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Closes the given connection.
            </summary>
            <param name="con">The connection.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.AfterPropertiesSet">
            <summary>
            Ensure that the connection or TargetConnectionFactory are specified.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.Dispose">
            <summary>
            Close the underlying shared connection. The provider of this ConnectionFactory needs to care for proper shutdown.
            As this object implements <see cref="T:System.IDisposable"/> an application context will automatically 
            invoke this on distruction o
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.ResetConnection">
            <summary>
            Resets the underlying shared Connection, to be reinitialized on next access.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SingleConnectionFactory.GetSharedConnection(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Wrap the given Connection with a proxy that delegates every method call to it
            but suppresses close calls. This is useful for allowing application code to
            handle a special framework Connection just like an ordinary Connection from a
            ConnectionFactory.
            </summary>
            <param name="target">The original connection to wrap.</param>
            <returns>the wrapped connection</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.SingleConnectionFactory.TargetConnectionFactory">
            <summary>
            Gets or sets the target connection factory which will be used to create a single
            connection.
            </summary>
            <value>The target connection factory.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.SingleConnectionFactory.ExceptionListener">
            <summary>
            Sets the exception listener.
            </summary>
            <value>The exception listener.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.SingleConnectionFactory.ReconnectOnException">
            <summary>
            Gets or sets a value indicating whether the single Connection
            should be reset (to be subsequently renewed) when a EMSException
            is reported by the underlying Connection.
            </summary>
            <remarks>
            Default is <code>false</code>.  Switch this to <code>true</code>
            to automatically trigger recover based on your messaging provider's
            exception notifications.
            <para>
            Internally, this will lead to a special ExceptionListener (this
            SingleConnectionFactory itself) being registered with the underlying
            Connection.  This can also be combined with a user-specified
            ExceptionListener, if desired.
            </para>
            </remarks>
            <value>
            	<c>true</c> attempt to reconnect on exception during next access; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.SingleConnectionFactory.ConnectionMonitor">
            <summary>
            Gets the connection monitor.
            </summary>
            <value>The connection monitor.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.SingleConnectionFactory.IsStarted">
            <summary>
            Gets a value indicating whether this instance is started.
            </summary>
            <value>
            	<c>true</c> if this instance is started; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.SingleConnectionFactory.ClientId">
            <summary>
            Gets the client id.
            </summary>
            <value>The client id.</value>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachingConnectionFactory.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.CachingConnectionFactory"/> class.
            and sets the ReconnectOnException to true
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachingConnectionFactory.#ctor(Spring.Messaging.Ems.Common.IConnectionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.CachingConnectionFactory"/> class for the given
            IConnectionFactory
            </summary>
            <param name="targetConnectionFactory">The target connection factory.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachingConnectionFactory.ResetConnection">
            <summary>
            Resets the Session cache as well as resetting the connection.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachingConnectionFactory.GetSession(Spring.Messaging.Ems.Common.IConnection,TIBCO.EMS.SessionMode)">
            <summary>
            Obtaining a cached Session.
            </summary>
            <param name="con">The connection to operate on.</param>
            <param name="mode">The session ack mode.</param>
            <returns>The Session to use
            </returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CachingConnectionFactory.GetCachedSessionWrapper(Spring.Messaging.Ems.Common.ISession,Spring.Collections.LinkedList)">
            <summary>
            Wraps the given Session so that it delegates every method call to the target session but
            adapts close calls. This is useful for allowing application code to
            handle a special framework Session just like an ordinary Session.
            </summary>
            <param name="targetSession">The original Session to wrap.</param>
            <param name="sessionList">The List of cached Sessions that the given Session belongs to.</param>
            <returns>The wrapped Session</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachingConnectionFactory.SessionCacheSize">
            <summary>
            Gets or sets the size of the session cache.
            </summary>
            <remarks>
            This cache size is the maximum limit for the number of cached Sessions
            per session acknowledgement type (auto, client, dups_ok, transacted).
            As a consequence, the actual number of cached Sessions may be up to
            four times as high as the specified value - in the unlikely case
            of mixing and matching different acknowledgement types.
            <para>
            Default is 1: caching a single Session, (re-)creating further ones on
            demand. Specify a number like 10 if you'd like to raise the number of cached
            Sessions; that said, 1 may be sufficient for low-concurrency scenarios.
            </para>
            </remarks>
            <value>The size of the session cache.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachingConnectionFactory.CacheProducers">
            <summary>
            Gets or sets a value indicating whether to cache MessageProducers per 
            Session instance. (more specifically: one MessageProducer per Destination 
            and Session).
            </summary>
            <remarks>
            <para>Default is "true". Switch this to "false" in order to always,
            recreate MessageProducers on demand.
            </para>
            </remarks>
            <value><c>true</c> if should cache message producers; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachingConnectionFactory.CacheConsumers">
            <summary>
            Gets or sets a value indicating whether o cache JMS MessageConsumers per 
            EMS Session instance. 
            </summary>
            <remarks>
            Mmore specifically: one MessageConsumer per Destination, selector String
            and Session. Note that durable subscribers will only be cached until
            logical closing of the Session handle.
            <para>
            Default is "true". Switch this to "false" in order to always
            recreate MessageConsumers on demand.
            </para>
            </remarks>
            <value><c>true</c> to cache consumers per session instance; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.CachingConnectionFactory.IsActive">
            <summary>
            Gets or sets a value indicating whether this instance is active.
            </summary>
            <value><c>true</c> if this instance is active; otherwise, <c>false</c>.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.ChainedExceptionListener">
            <summary>
            Implementation of Spring IExceptionListener interface that supports
            chaining allowing the addition of multiple ExceptionListener instances in order.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ChainedExceptionListener.AddListener(TIBCO.EMS.IExceptionListener)">
            <summary>
            Adds the exception listener to the chain
            </summary>
            <param name="listener">The listener.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ChainedExceptionListener.OnException(TIBCO.EMS.EMSException)">
            <summary>
            Called when an exception occurs in message processing.
            </summary>
            <param name="exception">The exception.</param>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.ChainedExceptionListener.Listeners">
            <summary>
            Gets the exception listeners as an array.
            </summary>
            <value>The exception listeners.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils">
            <summary> Helper class for obtaining transactional EMS resources
            for a given ConnectionFactory.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.ReleaseConnection(Spring.Messaging.Ems.Common.IConnection,Spring.Messaging.Ems.Common.IConnectionFactory,System.Boolean)">
            <summary>
            Releases the given connection, stopping it (if necessary) and eventually closing it.
            </summary>
            <remarks>Checks <see cref="M:Spring.Messaging.Ems.Connections.ISmartConnectionFactory.ShouldStop(Spring.Messaging.Ems.Common.IConnection)"/>, if available.
            This is essentially a more sophisticated version of 
            <see cref="M:Spring.Messaging.Ems.Support.EmsUtils.CloseConnection(Spring.Messaging.Ems.Common.IConnection,System.Boolean)"/>
            </remarks>
            <param name="connection">The connection to release. (if this is <code>null</code>, the call will be ignored)</param>
            <param name="cf">The ConnectionFactory that the Connection was obtained from. (may be <code>null</code>)</param>
            <param name="started">whether the Connection might have been started by the application.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.GetTargetSession(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Return the innermost target Session of the given Session. If the given
            Session is a decorated session, it will be unwrapped until a non-decorated
            Session is found. Otherwise, the passed-in Session will be returned as-is.
            </summary>
            <param name="session">The session to unwrap</param>
            <returns>The innermost target Session, or the passed-in one if no decorator</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.IsSessionTransactional(Spring.Messaging.Ems.Common.ISession,Spring.Messaging.Ems.Common.IConnectionFactory)">
            <summary>
            Determines whether the given JMS Session is transactional, that is,
            bound to the current thread by Spring's transaction facilities.
            </summary>
            <param name="session">The session to check.</param>
            <param name="cf">The ConnectionFactory that the Session originated from</param>
            <returns>
            	<c>true</c> if is session transactional, bound to current thread; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.GetTransactionalSession(Spring.Messaging.Ems.Common.IConnectionFactory,Spring.Messaging.Ems.Common.IConnection,System.Boolean)">
            <summary> Obtain a EMS Session that is synchronized with the current transaction, if any.</summary>
            <param name="cf">the ConnectionFactory to obtain a Session for
            </param>
            <param name="existingCon">the existing EMS Connection to obtain a Session for
            (may be <code>null</code>)
            </param>
            <param name="synchedLocalTransactionAllowed">whether to allow for a local EMS transaction
            that is synchronized with a Spring-managed transaction (where the main transaction
            might be a ADO.NET-based one for a specific DataSource, for example), with the EMS
            transaction committing right after the main transaction. If not allowed, the given
            ConnectionFactory needs to handle transaction enlistment underneath the covers.
            </param>
            <returns> the transactional Session, or <code>null</code> if none found
            </returns>
            <throws>  EMSException in case of EMS failure </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.DoGetTransactionalSession(System.Object,Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.ResourceFactory,System.Boolean)">
            <summary>
            Obtain a EMS Session that is synchronized with the current transaction, if any.
            </summary>
            <param name="resourceKey">the TransactionSynchronizationManager key to bind to
            (usually the ConnectionFactory)</param>
            <param name="resourceFactory">the ResourceFactory to use for extracting or creating
            EMS resources</param>
            <param name="startConnection">whether the underlying Connection approach should be
            started in order to allow for receiving messages. Note that a reused Connection
            may already have been started before, even if this flag is <code>false</code>.</param>
            <returns>
            the transactional Session, or <code>null</code> if none found
            </returns>
            <throws>EMSException in case of EMS failure </throws>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.ResourceFactory">
            <summary> Callback interface for resource creation.
            Serving as argument for the <code>DoGetTransactionalSession</code> method.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.ResourceFactory.GetSession(Spring.Messaging.Ems.Connections.EmsResourceHolder)">
            <summary> Fetch an appropriate Session from the given EmsResourceHolder.</summary>
            <param name="holder">the EmsResourceHolder
            </param>
            <returns> an appropriate Session fetched from the holder,
            or <code>null</code> if none found
            </returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.ResourceFactory.GetConnection(Spring.Messaging.Ems.Connections.EmsResourceHolder)">
            <summary> Fetch an appropriate Connection from the given EmsResourceHolder.</summary>
            <param name="holder">the EmsResourceHolder
            </param>
            <returns> an appropriate Connection fetched from the holder,
            or <code>null</code> if none found
            </returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.ResourceFactory.CreateConnection">
            <summary> Create a new EMS Connection for registration with a EmsResourceHolder.</summary>
            <returns> the new EMS Connection
            </returns>
            <throws>EMSException if thrown by EMS API methods </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.ResourceFactory.CreateSession(Spring.Messaging.Ems.Common.IConnection)">
            <summary> Create a new EMS Session for registration with a EmsResourceHolder.</summary>
            <param name="con">the EMS Connection to create a Session for
            </param>
            <returns> the new EMS Session
            </returns>
            <throws>EMSException if thrown by EMS API methods </throws>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.ResourceFactory.SynchedLocalTransactionAllowed">
            <summary>
            Return whether to allow for a local EMS transaction that is synchronized with
            a Spring-managed transaction (where the main transaction might be a ADO.NET-based
            one for a specific IDbProvider, for example), with the EMS transaction
            committing right after the main transaction.
            Returns whether to allow for synchronizing a local EMS transaction
            </summary>
            
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.EmsResourceSynchronization">
            <summary> Callback for resource cleanup at the end of a non-native EMS transaction
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.EmsResourceHolder">
             <summary>Connection holder, wrapping a EMS Connection and a EMS Session.
             EmsTransactionManager binds instances of this class to the thread,
             for a given EMS ConnectionFactory.
            
             <p>Note: This is an SPI class, not intended to be used by applications.</p>
            
             </summary>
             <author>Juergen Hoeller</author>
             <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.#ctor">
            <summary> Create a new EmsResourceHolder that is open for resources to be added.</summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.#ctor(Spring.Messaging.Ems.Common.IConnectionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.EmsResourceHolder"/> class
            at is open for resources to be added.
            </summary>
            <param name="connectionFactory">The connection factory that this
            resource holder is associated with (may be <code>null</code>)
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.#ctor(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.EmsResourceHolder"/> class for the
            given Session.
            </summary>
            <param name="session">The session.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.#ctor(Spring.Messaging.Ems.Common.IConnection,Spring.Messaging.Ems.Common.ISession)">
            <summary> Create a new EmsResourceHolder for the given EMS resources.</summary>
            <param name="connection">the EMS Connection
            </param>
            <param name="session">the EMS Session
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.#ctor(Spring.Messaging.Ems.Common.IConnectionFactory,Spring.Messaging.Ems.Common.IConnection,Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.EmsResourceHolder"/> class.
            </summary>
            <param name="connectionFactory">The connection factory.</param>
            <param name="connection">The connection.</param>
            <param name="session">The session.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.AddConnection(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Adds the connection to the list of resources managed by this holder.
            </summary>
            <param name="connection">The connection.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.AddSession(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Adds the session to the list of resources managed by this holder.
            </summary>
            <param name="session">The session.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.AddSession(Spring.Messaging.Ems.Common.ISession,Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Adds the session and connection to the list of resources managed by this holder.
            </summary>
            <param name="session">The session.</param>
            <param name="connection">The connection.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.GetConnection">
            <summary>
            Gets the connection managed by this resource holder
            </summary>
            <returns>A Connection, or null if no managed connection.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.GetConnection(System.Type)">
            <summary>
            Gets the connection of a given type managed by this resource holder.  This is used
            when storing Queue or Topic Connections (from the older 1.0.2 API) as compared to the
            'unified domain' API , just Connection, in the newer 1.2 API.
            </summary>
            <param name="connectionType">Type of the connection.</param>
            <returns>The connection, or null if not found.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.GetSession">
            <summary>
            Gets the first session manged by this holder or null if not available.
            </summary>
            <returns>The session or null if not available.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.GetSession(System.Type)">
            <summary>
            Gets the session managed by this holder by type.
            </summary>
            <param name="sessionType">Type of the session.</param>
            <returns>The session or null if not available.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.GetSession(System.Type,Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Gets the session of a given type associated with the given connection
            </summary>
            <param name="sessionType">Type of the session.</param>
            <param name="connection">The connection.</param>
            <returns>The sessin or null if not available.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.CommitAll">
            <summary>
            Commits all sessions.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.CloseAll">
            <summary>
            Closes all sessions then stops and closes all connections, in that order.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsResourceHolder.ContainsSession(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Determines whether the holder contains the specified session.
            </summary>
            <param name="session">The session.</param>
            <returns>
            	<c>true</c> if the holder contains the specified session; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.EmsResourceHolder.Frozen">
            <summary>
            Gets a value indicating whether this <see cref="T:Spring.Messaging.Ems.Connections.EmsResourceHolder"/> is frozen, namely that 
            additional resources can be registered with the holder.  If using any of the constructors with
            a Session, the holder will be set to the frozen state.
            </summary>
            <value><c>true</c> if frozen; otherwise, <c>false</c>.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.EmsTransactionManager">
            <summary>
            A <see cref="T:Spring.Transaction.Support.AbstractPlatformTransactionManager"/> implementation
            for a single EMS <code>ConnectionFactory</code>. Binds a 
            Connection/Session pair from the specified ConnecctionFactory to the thread,
            potentially allowing for one thread-bound Session per ConnectionFactory.
            </summary>
            <remarks>
            <para>
            Application code is required to retrieve the transactional Session via
            <see cref="M:Spring.Messaging.Ems.Connections.ConnectionFactoryUtils.GetTransactionalSession(Spring.Messaging.Ems.Common.IConnectionFactory,Spring.Messaging.Ems.Common.IConnection,System.Boolean)"/>.  Spring's
            <see cref="T:Spring.Messaging.Ems.Core.EmsTemplate"/> will autodetect a thread-bound Session and 
            automatically participate in it.
            </para>
            <para>
            Transaction synchronization is turned off by default, as this manager might be used
            alongside an IDbProvider based Spring transaction manager such as the
            AdoPlatformTransactionManager, which has stronger needs for synchronization.
            </para>
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.EmsTransactionManager"/> class.
            </summary>
            <remarks>
            The ConnectionFactory has to be set before using the instance. 
            This constructor can be used to prepare a EmsTemplate via a ApplicationContext,
            typically setting the ConnectionFactory via ConnectionFactory property.
            <para>
            Turns off transaction synchronization by default, as this manager might
            be used alongside a dbprovider-based Spring transaction manager like
            AdoPlatformTransactionManager, which has stronger needs for synchronization.
            Only one manager is allowed to drive synchronization at any point of time.
            </para>
            </remarks>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.#ctor(Spring.Messaging.Ems.Common.IConnectionFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Connections.EmsTransactionManager"/> class
            given a ConnectionFactory.
            </summary>
            <param name="connectionFactory">The connection factory to obtain connections from.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.AfterPropertiesSet">
            <summary>
            Make sure the ConnectionFactory has been set.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.DoGetTransaction">
            <summary>
            Get the EmsTransactionObject.
            </summary>
            <returns>he EmsTransactionObject.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.DoBegin(System.Object,Spring.Transaction.ITransactionDefinition)">
            <summary>
            Begin a new transaction with the given transaction definition.
            </summary>
            <param name="transaction">Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
            <param name="definition"><see cref="T:Spring.Transaction.ITransactionDefinition"/> instance, describing
            propagation behavior, isolation level, timeout etc.</param>
            <remarks>
            Does not have to care about applying the propagation behavior,
            as this has already been handled by this abstract manager.
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of creation or system errors.
            </exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.DoSuspend(System.Object)">
            <summary>
            Suspend the resources of the current transaction.
            </summary>
            <param name="transaction">Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
            <returns>
            An object that holds suspended resources (will be kept unexamined for passing it into
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoResume(System.Object,System.Object)"/>.)
            </returns>
            <remarks>
            Transaction synchronization will already have been suspended.
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            in case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.DoResume(System.Object,System.Object)">
            <summary>
            Resume the resources of the current transaction.
            </summary>
            <param name="transaction">Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
            <param name="suspendedResources">The object that holds suspended resources as returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoSuspend(System.Object)"/>.</param>
            <remarks>Transaction synchronization will be resumed afterwards.
            </remarks>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.DoCommit(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Perform an actual commit on the given transaction.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.DoRollback(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Perform an actual rollback on the given transaction.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.DoSetRollbackOnly(Spring.Transaction.Support.DefaultTransactionStatus)">
            <summary>
            Set the given transaction rollback-only. Only called on rollback
            if the current transaction takes part in an existing one.
            </summary>
            <param name="status">The status representation of the transaction.</param>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.DoCleanupAfterCompletion(System.Object)">
            <summary>
            Cleanup resources after transaction completion.
            </summary>
            <param name="transaction">Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
            <remarks>
            <para>
            Called after <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoCommit(Spring.Transaction.Support.DefaultTransactionStatus)"/>
            and
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoRollback(Spring.Transaction.Support.DefaultTransactionStatus)"/>
            execution on any outcome.
            </para>
            </remarks>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.IsExistingTransaction(System.Object)">
            <summary>
            Check if the given transaction object indicates an existing transaction
            (that is, a transaction which has already started).
            </summary>
            <param name="transaction">Transaction object returned by
            <see cref="M:Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>.</param>
            <returns>
            True if there is an existing transaction.
            </returns>
            <exception cref="T:Spring.Transaction.TransactionException">
            In the case of system errors.
            </exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.CreateConnection">
            <summary>
            Creates the connection via thie manager's ConnectionFactory.
            </summary>
            <returns>The new Connection</returns>
            <exception cref="T:TIBCO.EMS.EMSException">If thrown by underlying messaging APIs</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.EmsTransactionManager.CreateSession(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Creates the session for the given Connection
            </summary>
            <param name="connection">The connection to create a Session for.</param>
            <returns>the new Session</returns>
            <exception cref="T:TIBCO.EMS.EMSException">If thrown by underlying messaging APIs</exception>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.EmsTransactionManager.ConnectionFactory">
            <summary>
            Gets or sets the connection factory that this instance should manage transaction.
            for.
            </summary>
            <value>The connection factory.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Connections.EmsTransactionManager.ResourceFactory">
            <summary>
            Gets the resource factory that this transaction manager operates on,
            In tihs case the ConnectionFactory
            </summary>
            <value>The ConnectionFactory.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.EmsTransactionManager.EmsTransactionObject">
            <summary>
            EMS Transaction object, representing a EmsResourceHolder.
            Used as transaction object by EMSTransactionManager
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.ISmartConnectionFactory">
            <summary>
            Extension of the <code>IConnectionFactory</code> interface, 
            indicating how to release Connections obtained from it.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.ISmartConnectionFactory.ShouldStop(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Shoulds we stop the connection, obtained from this ConnectionFactory?
            </summary>
            <param name="con">The connection to check.</param>
            <returns>wheter a stop call is necessary</returns>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.InternalChainedExceptionListener">
            <summary>
            Internal chained ExceptionListener for handling the internal recovery listener
            in combination with a user-specified listener.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.CloseSupressingConnection.ToString">
            <summary>
            Add information to show this is a shared EMS connection
            </summary>
            <returns>Description of connection wrapper</returns>
        </member>
        <member name="T:Spring.Messaging.Ems.Connections.SynchedLocalTransactionFailedException">
            <summary> Exception thrown when a synchronized local transaction failed to complete
            (after the main transaction has already completed).
            </summary>
            <author>Jergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SynchedLocalTransactionFailedException.#ctor(System.String)">
            <summary>
            Creates a new instance of the SynchedLocalTransactionFailedException class. with the specified message.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Connections.SynchedLocalTransactionFailedException.#ctor(System.String,System.Exception)">
            <summary>
            Creates a new instance of the SynchedLocalTransactionFailedException class with the specified message
            and root cause.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
            <param name="rootCause">
            The root exception that is being wrapped.
            </param>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.BrowserDelegate">
            <summary>
            Delegate callback for browsing the messages in an EMS queue.
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.EmsGatewaySupport">
             <summary>
             Convenient super class for application classes that need EMS access.
             </summary>
             <remarks>
              Requires a ConnectionFactory or a EmsTemplate instance to be set.
              It will create its own EmsTemplate if a ConnectionFactory is passed in.
              A custom EmsTemplate instance can be created for a given ConnectionFactory
              through overriding the <code>createEmsTemplate</code> method.
            
             </remarks>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsGatewaySupport.CreateEmsTemplate(Spring.Messaging.Ems.Common.IConnectionFactory)">
             <summary>
             Creates a EmsTemplate for the given ConnectionFactory.
             </summary>
             <remarks>Only invoked if populating the gateway with a ConnectionFactory reference.
             Can be overridden in subclasses to provide a different EmsTemplate instance
             </remarks>
            
             <param name="connectionFactory">The connection factory.</param>
             <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsGatewaySupport.AfterPropertiesSet">
            <summary>
            Ensures that the JmsTemplate is specified and calls <see cref="M:Spring.Messaging.Ems.Core.EmsGatewaySupport.InitGateway"/>.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsGatewaySupport.InitGateway">
            <summary>
            Subclasses can override this for custom initialization behavior.
            Gets called after population of this instance's properties.
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsGatewaySupport.EmsTemplate">
            <summary>
            Gets or sets the EMS template for the gateway.
            </summary>
            <value>The EMS template.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsGatewaySupport.ConnectionFactory">
            <summary>
            Gets or sets he EMS connection factory to be used by the gateway.
            Will automatically create a EmsTemplate for the given ConnectionFactory.
            </summary>
            <value>The connection factory.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.EmsTemplate">
             <summary> Helper class that simplifies EMS access code.</summary>
             <remarks>
             <para>If you want to use dynamic destination creation, you must specify
             the type of EMS destination to create, using the "pubSubDomain" property.
             For other operations, this is not necessary.
             Point-to-Point (Queues) is the default domain.</para>
            
             <para>Default settings for EMS Sessions is "auto-acknowledge".</para>
            
             <para>This template uses a DynamicDestinationResolver and a SimpleMessageConverter
             as default strategies for resolving a destination name or converting a message,
             respectively.</para>
            
             </remarks>
             <author>Mark Pollack</author>
             <author>Juergen Hoeller</author>
             <author>Mark Pollack (.NET)</author>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Destinations.EmsDestinationAccessor">
            <summary> Base class for EmsTemplate} and other
            EMS-accessing gateway helpers, adding destination-related properties to
            EmsAccessor's common properties.
            </summary>
            <remarks>
            <p>Not intended to be used directly. See EmsTemplate.</p>
            
            </remarks>
            <author>Juergen Hoeller </author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.EmsAccessor">
            <summary> Base class for EmsTemplate and other EMS-accessing gateway helpers</summary>
            <remarks>It defines common properties like the ConnectionFactory}. The subclass
            EmsDestinationAccessor adds further, destination-related properties.
            <para>
            Not intended to be used directly. See EmsTemplate.
            </para>
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsAccessor.AfterPropertiesSet">
            <summary>
            Verify that ConnectionFactory property has been set.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsAccessor.CreateConnection">
            <summary>
            Creates the connection via the ConnectionFactory.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsAccessor.CreateSession(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Creates the session for the given Connection
            </summary>
            <param name="con">The connection to create a session for.</param>
            <returns>The new session</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsAccessor.IsClientAcknowledge(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Returns whether the Session is in client acknowledgement mode.
            </summary>
            <param name="session">The session to check.</param>
            <returns>true if in client ack mode, false otherwise</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.EmsAccessor.ConnectionFactory">
            <summary>
            Gets or sets the connection factory to use for obtaining EMS Connections.
            </summary>
            <value>The connection factory.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.EmsAccessor.SessionAcknowledgeMode">
            <summary>
            Gets or sets the session acknowledge mode for EMS Sessions including whether or not the session is transacted
            </summary>
            <remarks>
            Set the EMS acknowledgement mode that is used when creating a EMS
            Session to send a message. The default is AUTO_ACKNOWLEDGE.
            </remarks>
            <value>The session acknowledge mode.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.EmsAccessor.SessionTransacted">
            <summary>
            Set the transaction mode that is used when creating a EMS Session.
            Default is "false".
            </summary>
            <remarks>
            <para>Setting this flag to "true" will use a short local EMS transaction
            when running outside of a managed transaction, and a synchronized local
            EMS transaction in case of a managed transaction being present. 
            The latter has the effect of a local EMS
            transaction being managed alongside the main transaction (which might
            be a native ADO.NET transaction), with the EMS transaction committing
            right after the main transaction.
            </para> 
            </remarks>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Destinations.EmsDestinationAccessor.ResolveDestinationName(Spring.Messaging.Ems.Common.ISession,System.String)">
            <summary>
            Resolves the given destination name to a EMS destination.
            </summary>
            <param name="session">The current session.</param>
            <param name="destinationName">Name of the destination.</param>
            <returns>The located Destination</returns>
            <exception cref="T:TIBCO.EMS.EMSException">If resolution failed.</exception>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Destinations.EmsDestinationAccessor.DestinationResolver">
            <summary>
            Gets or sets the destination resolver that is to be used to resolve
            Destination references for this accessor.
            </summary>
            <remarks>The default resolver is a DynamicDestinationResolver. Specify a
            JndDestinationResolver for resolving destination names as JNDI locations.
            </remarks>
            <value>The destination resolver.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Destinations.EmsDestinationAccessor.PubSubDomain">
            <summary>
            Gets or sets a value indicating whether Publish/Subscribe
            domain (Topics) is used. Otherwise, the Point-to-Point domain
            (Queues) is used.
            
            </summary>
            <remarks>this
            setting tells what type of destination to create if dynamic destinations are enabled.</remarks>
            <value><c>true</c> if Publish/Subscribe domain; otherwise, <c>false</c>
            for the Point-to-Point domain.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.IEmsOperations">
            <summary>Specifies a basic set of EMS operations.
            </summary>
            <remarks>
            <p>Implemented by EmsTemplate. Not often used but a useful option
            to enhance testability, as it can easily be mocked or stubbed.</p>
            
            <p>Provides <code>EmsTemplate's</code> <code>send(..)</code> and
            <code>receive(..)</code> methods that mirror various EMS API methods.
            See the EMS specification and EMS API docs for details on those methods.
            </p>
            </remarks>
            <author>Mark Pollack</author>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Execute(Spring.Messaging.Ems.Core.SessionDelegate)">
            <summary> Execute the action specified by the given action object within
            a EMS Session.
            </summary>
            <param name="del">delegate that exposes the session</param>
            <returns> the result object from working with the session
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Execute(Spring.Messaging.Ems.Core.ISessionCallback)">
            <summary> Execute the action specified by the given action object within
            a EMS Session.
            </summary>
            <param name="action">callback object that exposes the session
            </param>
            <returns> the result object from working with the session
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Execute(Spring.Messaging.Ems.Core.IProducerCallback)">
            <summary> Send a message to a EMS destination. The callback gives access to
            the EMS session and MessageProducer in order to do more complex
            send operations.
            </summary>
            <param name="action">callback object that exposes the session/producer pair
            </param>
            <returns> the result object from working with the session
            </returns>
            <throws>EMSException  if there is any problem </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Execute(Spring.Messaging.Ems.Core.ProducerDelegate)">
            <summary> Send a message to a EMS destination. The callback gives access to
            the EMS session and MessageProducer in order to do more complex
            send operations.
            </summary>
            <param name="del">delegate that exposes the session/producer pair
            </param>
            <returns> the result object from working with the session
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Send(Spring.Messaging.Ems.Core.IMessageCreator)">
            <summary> Send a message to the default destination.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="messageCreator">callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Send(TIBCO.EMS.Destination,Spring.Messaging.Ems.Core.IMessageCreator)">
            <summary> Send a message to the specified destination.
            The IMessageCreator callback creates the message given a Session.
            </summary>
            <param name="destination">the destination to send this message to
            </param>
            <param name="messageCreator">callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Send(System.String,Spring.Messaging.Ems.Core.IMessageCreator)">
            <summary> Send a message to the specified destination.
            The IMessageCreator callback creates the message given a Session.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="messageCreator">callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.SendWithDelegate(Spring.Messaging.Ems.Core.MessageCreatorDelegate)">
            <summary> Send a message to the default destination.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="messageCreatorDelegate">delegate callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.SendWithDelegate(TIBCO.EMS.Destination,Spring.Messaging.Ems.Core.MessageCreatorDelegate)">
            <summary> Send a message to the specified destination.
            The IMessageCreator callback creates the message given a Session.
            </summary>
            <param name="destination">the destination to send this message to
            </param>
            <param name="messageCreatorDelegate">delegate callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.SendWithDelegate(System.String,Spring.Messaging.Ems.Core.MessageCreatorDelegate)">
            <summary> Send a message to the specified destination.
            The IMessageCreator callback creates the message given a Session.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="messageCreatorDelegate">delegate callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSend(System.Object)">
            <summary> Send the given object to the default destination, converting the object
            to a EMS message with a configured IMessageConverter.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="message">the object to convert to a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSend(TIBCO.EMS.Destination,System.Object)">
            <summary> Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter.
            </summary>
            <param name="destination">the destination to send this message to
            </param>
            <param name="message">the object to convert to a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSend(System.String,System.Object)">
            <summary> Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="message">the object to convert to a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSend(System.Object,Spring.Messaging.Ems.Core.IMessagePostProcessor)">
            <summary> Send the given object to the default destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="message">the object to convert to a message
            </param>
            <param name="postProcessor">the callback to modify the message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSend(TIBCO.EMS.Destination,System.Object,Spring.Messaging.Ems.Core.IMessagePostProcessor)">
            <summary> Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            </summary>
            <param name="destination">the destination to send this message to
            </param>
            <param name="message">the object to convert to a message
            </param>
            <param name="postProcessor">the callback to modify the message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSend(System.String,System.Object,Spring.Messaging.Ems.Core.IMessagePostProcessor)">
            <summary> Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="message">the object to convert to a message.
            </param>
            <param name="postProcessor">the callback to modify the message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSendWithDelegate(System.Object,Spring.Messaging.Ems.Core.MessagePostProcessorDelegate)">
            <summary>
            Send the given object to the default destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="message">the object to convert to a message</param>
            <param name="postProcessor">the callback to modify the message</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSendWithDelegate(TIBCO.EMS.Destination,System.Object,Spring.Messaging.Ems.Core.MessagePostProcessorDelegate)">
            <summary>
            Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            </summary>
            <param name="destination">the destination to send this message to</param>
            <param name="message">the object to convert to a message</param>
            <param name="postProcessor">the callback to modify the message</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ConvertAndSendWithDelegate(System.String,System.Object,Spring.Messaging.Ems.Core.MessagePostProcessorDelegate)">
            <summary>
            Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="message">the object to convert to a message.</param>
            <param name="postProcessor">the callback to modify the message</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Receive">
            <summary> Receive a message synchronously from the default destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            <p>This will only work with a default destination specified!</p>
            </summary>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Receive(TIBCO.EMS.Destination)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destination">the destination to receive a message from
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Receive(System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveSelected(System.String)">
            <summary> Receive a message synchronously from the default destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveSelected(TIBCO.EMS.Destination,System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destination">the destination to receive a message from
            </param>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveSelected(System.String,System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveAndConvert">
            <summary> Receive a message synchronously from the default destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            <p>This will only work with a default destination specified!</p>
            </summary>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveAndConvert(TIBCO.EMS.Destination)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destination">the destination to receive a message from
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveAndConvert(System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveSelectedAndConvert(System.String)">
            <summary> Receive a message synchronously from the default destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveSelectedAndConvert(TIBCO.EMS.Destination,System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destination">the destination to receive a message from
            </param>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.ReceiveSelectedAndConvert(System.String,System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Browse(Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in the default EMS queue. The callback gives access to the EMS
            Session and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <returns>the result object from working with the session</returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>        
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Browse(TIBCO.EMS.Queue,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queue">The queue to browse.</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <returns>the result object from working with the session</returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>        
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.Browse(System.String,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queueName">Name of the queue to browse, 
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseSelected(System.String,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseSelected(TIBCO.EMS.Queue,System.String,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queue">The queue to browse.</param>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <returns></returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseSelected(System.String,System.String,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queueName">Name of the queue to browse, 
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <returns></returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseWithDelegate(Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in the default EMS queue. The callback gives access to the EMS
            Session and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <returns>the result object from working with the session</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseWithDelegate(TIBCO.EMS.Queue,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queue">The queue to browse.</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <returns>the result object from working with the session</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseWithDelegate(System.String,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queueName">Name of the queue to browse, 
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseSelectedWithDelegate(System.String,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseSelectedWithDelegate(TIBCO.EMS.Queue,System.String,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queue">The queue to browse.</param>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <returns></returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IEmsOperations.BrowseSelectedWithDelegate(System.String,System.String,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queueName">Name of the queue to browse, 
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <returns></returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="F:Spring.Messaging.Ems.Core.EmsTemplate.DEFAULT_RECEIVE_TIMEOUT">
            <summary>
            Timeout value indicating that a receive operation should
            check if a message is immediately available without blocking.	 
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.#ctor">
            <summary> Create a new EmsTemplate.</summary>
            <remarks>
            <para>Note: The ConnectionFactory has to be set before using the instance.
            This constructor can be used to prepare a EmsTemplate via an ObjectFactory,
            typically setting the ConnectionFactory.</para>
            </remarks>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.#ctor(Spring.Messaging.Ems.Common.IConnectionFactory)">
            <summary> Create a new EmsTemplate, given a ConnectionFactory.</summary>
            <param name="connectionFactory">the ConnectionFactory to obtain Connections from
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.InitDefaultStrategies">
            <summary> Initialize the default implementations for the template's strategies:
            DynamicDestinationResolver and SimpleMessageConverter.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Execute(Spring.Messaging.Ems.Core.ISessionCallback,System.Boolean)">
            <summary> Execute the action specified by the given action object within a
            EMS Session.
            </summary>
            <remarks> Generalized version of <code>execute(SessionCallback)</code>,
            allowing the EMS Connection to be started on the fly.
            <p>Use <code>execute(SessionCallback)</code> for the general case.
            Starting the EMS Connection is just necessary for receiving messages,
            which is preferably achieved through the <code>receive</code> methods.</p>
            </remarks>
            <param name="action">callback object that exposes the session
            </param>
            <param name="startConnection">Start the connection before performing callback action.
            </param>
            <returns> the result object from working with the session
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Execute(Spring.Messaging.Ems.Core.SessionDelegate,System.Boolean)">
            <summary> Execute the action specified by the given action object within a
            EMS Session.
            </summary>
            <remarks> Generalized version of <code>execute(SessionCallback)</code>,
            allowing the EMS Connection to be started on the fly.
            <p>Use <code>execute(SessionCallback)</code> for the general case.
            Starting the EMS Connection is just necessary for receiving messages,
            which is preferably achieved through the <code>receive</code> methods.</p>
            </remarks>
            <param name="action">callback object that exposes the session
            </param>
            <param name="startConnection">Start the connection before performing callback action.
            </param>
            <returns> the result object from working with the session
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.DoConvertFromMessage(TIBCO.EMS.Message)">
            <summary>
            Extract the content from the given JMS message.
            </summary>
            <param name="message">The Message to convert (can be <code>null</code>).</param>
            <returns>The content of the message, or <code>null</code> if none</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.GetConnection(Spring.Messaging.Ems.Connections.EmsResourceHolder)">
            <summary> Fetch an appropriate Connection from the given EmsResourceHolder.
            </summary>
            <param name="holder">the EmsResourceHolder
            </param>
            <returns> an appropriate Connection fetched from the holder,
            or <code>null</code> if none found
            </returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.GetSession(Spring.Messaging.Ems.Connections.EmsResourceHolder)">
            <summary> Fetch an appropriate Session from the given EmsResourceHolder.
            </summary>
            <param name="holder">the EmsResourceHolder
            </param>
            <returns> an appropriate Session fetched from the holder,
            or <code>null</code> if none found
            </returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.CreateProducer(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination)">
            <summary> Create a EMS MessageProducer for the given Session and Destination,
            configuring it to disable message ids and/or timestamps (if necessary).
            <p>Delegates to <code>doCreateProducer</code> for creation of the raw
            EMS MessageProducer</p>
            </summary>
            <param name="session">the EMS Session to create a MessageProducer for
            </param>
            <param name="destination">the EMS Destination to create a MessageProducer for
            </param>
            <returns> the new EMS MessageProducer
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
            <seealso cref="M:Spring.Messaging.Ems.Core.EmsTemplate.DoCreateProducer(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination)">
            </seealso>
            <seealso cref="P:Spring.Messaging.Ems.Core.EmsTemplate.MessageIdEnabled">
            </seealso>
            <seealso cref="P:Spring.Messaging.Ems.Core.EmsTemplate.MessageTimestampEnabled">
            </seealso>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.IsSessionLocallyTransacted(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Determines whether the given Session is locally transacted, that is, whether
            its transaction is managed by this template class's Session handling
            and not by an external transaction coordinator. 
            </summary>
            <remarks>
            The Session's own transacted flag will already have been checked
            before. This method is about finding out whether the Session's transaction
            is local or externally coordinated.
            </remarks>
            <param name="session">The session to check.</param>
            <returns>
            	<c>true</c> if the session is locally transacted; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.DoCreateProducer(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination)">
            <summary> Create a raw EMS MessageProducer for the given Session and Destination.
            </summary>
            <remarks>If CacheJmsResource is true, then the producer 
            will be created upon the first invocation and will retrun the same
            producer (per destination) on all subsequent calls.
            </remarks>
            <param name="session">the EMS Session to create a MessageProducer for
            </param>
            <param name="destination">the EMS Destination to create a MessageProducer for
            </param>
            <returns> the new EMS MessageProducer
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.CreateConsumer(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination,System.String)">
            <summary> Create a EMS MessageConsumer for the given Session and Destination.
            </summary>
            <param name="session">the EMS Session to create a MessageConsumer for
            </param>
            <param name="destination">the EMS Destination to create a MessageConsumer for
            </param>
            <param name="messageSelector">the message selector for this consumer (can be <code>null</code>)
            </param>
            <returns> the new EMS MessageConsumer
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.DoSend(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination,Spring.Messaging.Ems.Core.MessageCreatorDelegate)">
            <summary>
            Send the given message.
            </summary>
            <param name="session">The session to operate on.</param>
            <param name="destination">The destination to send to.</param>
            <param name="messageCreatorDelegate">The message creator delegate callback to create a Message.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.DoSend(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination,Spring.Messaging.Ems.Core.IMessageCreator)">
            <summary>
            Send the given message.
            </summary>
            <param name="session">The session to operate on.</param>
            <param name="destination">The destination to send to.</param>
            <param name="messageCreator">The message creator callback to create a Message.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.DoSend(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination,Spring.Messaging.Ems.Core.IMessageCreator,Spring.Messaging.Ems.Core.MessageCreatorDelegate)">
            <summary> Send the given EMS message.</summary>
            <param name="session">the EMS Session to operate on
            </param>
            <param name="destination">the EMS Destination to send to
            </param>
            <param name="messageCreator">callback to create a EMS Message
            </param>
            <param name="messageCreatorDelegate">delegate callback to create a EMS Message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.DoSend(Spring.Messaging.Ems.Common.IMessageProducer,TIBCO.EMS.Message)">
            <summary> Actually send the given EMS message.</summary>
            <param name="producer">the EMS MessageProducer to send with
            </param>
            <param name="message">the EMS Message to send
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Execute(Spring.Messaging.Ems.Core.SessionDelegate)">
            <summary>
            Execute the action specified by the given action object within
            a EMS Session.
            </summary>
            <param name="del">delegate that exposes the session</param>
            <returns>
            the result object from working with the session
            </returns>
            <remarks>
            	<para>Note that the value of PubSubDomain affects the behavior of this method.
            If PubSubDomain equals true, then a Session is passed to the callback.
            If false, then a Session is passed to the callback.</para>b
            </remarks>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Execute(Spring.Messaging.Ems.Core.ISessionCallback)">
            <summary> Execute the action specified by the given action object within
            a EMS Session.
            <p>Note: The value of PubSubDomain affects the behavior of this method.
            If PubSubDomain equals true, then a Session is passed to the callback.
            If false, then a Session is passed to the callback.</p>
            </summary>
            <param name="action">callback object that exposes the session
            </param>
            <returns> the result object from working with the session
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Execute(Spring.Messaging.Ems.Core.IProducerCallback)">
            <summary> Send a message to a EMS destination. The callback gives access to
            the EMS session and MessageProducer in order to do more complex
            send operations.
            </summary>
            <param name="action">callback object that exposes the session/producer pair
            </param>
            <returns> the result object from working with the session
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Execute(Spring.Messaging.Ems.Core.ProducerDelegate)">
            <summary> Send a message to a EMS destination. The callback gives access to
            the EMS session and MessageProducer in order to do more complex
            send operations.
            </summary>
            <param name="del">delegate that exposes the session/producer pair
            </param>
            <returns> the result object from working with the session
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.SendWithDelegate(Spring.Messaging.Ems.Core.MessageCreatorDelegate)">
            <summary> Send a message to the default destination.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="messageCreatorDelegate">delegate callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.SendWithDelegate(TIBCO.EMS.Destination,Spring.Messaging.Ems.Core.MessageCreatorDelegate)">
            <summary> Send a message to the specified destination.
            The MessageCreator callback creates the message given a Session.
            </summary>
            <param name="destination">the destination to send this message to
            </param>
            <param name="messageCreatorDelegate">delegate callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.SendWithDelegate(System.String,Spring.Messaging.Ems.Core.MessageCreatorDelegate)">
            <summary> Send a message to the specified destination.
            The MessageCreator callback creates the message given a Session.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="messageCreatorDelegate">delegate callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Send(Spring.Messaging.Ems.Core.IMessageCreator)">
            <summary> Send a message to the default destination.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="messageCreator">callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Send(TIBCO.EMS.Destination,Spring.Messaging.Ems.Core.IMessageCreator)">
            <summary> Send a message to the specified destination.
            The MessageCreator callback creates the message given a Session.
            </summary>
            <param name="destination">the destination to send this message to
            </param>
            <param name="messageCreator">callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Send(System.String,Spring.Messaging.Ems.Core.IMessageCreator)">
            <summary> Send a message to the specified destination.
            The MessageCreator callback creates the message given a Session.
            </summary>
            <param name="destinationName">the destination to send this message to
            </param>
            <param name="messageCreator">callback to create a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSend(System.Object)">
            <summary> Send the given object to the default destination, converting the object
            to a EMS message with a configured IMessageConverter.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="message">the object to convert to a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSend(TIBCO.EMS.Destination,System.Object)">
            <summary> Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter.
            </summary>
            <param name="destination">the destination to send this message to
            </param>
            <param name="message">the object to convert to a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSend(System.String,System.Object)">
            <summary> Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="message">the object to convert to a message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSend(System.Object,Spring.Messaging.Ems.Core.IMessagePostProcessor)">
            <summary> Send the given object to the default destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="message">the object to convert to a message
            </param>
            <param name="postProcessor">the callback to modify the message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSend(TIBCO.EMS.Destination,System.Object,Spring.Messaging.Ems.Core.IMessagePostProcessor)">
            <summary> Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            </summary>
            <param name="destination">the destination to send this message to
            </param>
            <param name="message">the object to convert to a message
            </param>
            <param name="postProcessor">the callback to modify the message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSend(System.String,System.Object,Spring.Messaging.Ems.Core.IMessagePostProcessor)">
            <summary> Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="message">the object to convert to a message.
            </param>
            <param name="postProcessor">the callback to modify the message
            </param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSendWithDelegate(System.Object,Spring.Messaging.Ems.Core.MessagePostProcessorDelegate)">
            <summary>
            Send the given object to the default destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="message">the object to convert to a message</param>
            <param name="postProcessor">the callback to modify the message</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSendWithDelegate(TIBCO.EMS.Destination,System.Object,Spring.Messaging.Ems.Core.MessagePostProcessorDelegate)">
            <summary>
            Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            </summary>
            <param name="destination">the destination to send this message to</param>
            <param name="message">the object to convert to a message</param>
            <param name="postProcessor">the callback to modify the message</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ConvertAndSendWithDelegate(System.String,System.Object,Spring.Messaging.Ems.Core.MessagePostProcessorDelegate)">
            <summary>
            Send the given object to the specified destination, converting the object
            to a EMS message with a configured IMessageConverter. The IMessagePostProcessor
            callback allows for modification of the message after conversion.
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="message">the object to convert to a message.</param>
            <param name="postProcessor">the callback to modify the message</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Receive">
            <summary> Receive a message synchronously from the default destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            <p>This will only work with a default destination specified!</p>
            </summary>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Receive(TIBCO.EMS.Destination)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destination">the destination to receive a message from
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Receive(System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveSelected(System.String)">
            <summary> Receive a message synchronously from the default destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveSelected(TIBCO.EMS.Destination,System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destination">the destination to receive a message from
            </param>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveSelected(System.String,System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message received by the consumer, or <code>null</code> if the timeout expires
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.DoReceive(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination,System.String)">
            <summary>
            Receive a message.
            </summary>
            <param name="session">The session to operate on.</param>
            <param name="destination">The destination to receive from.</param>
            <param name="messageSelector">The message selector for this consumer (can be <code>null</code></param>
            <returns>The Message received, or <code>null</code> if none.</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.DoReceive(Spring.Messaging.Ems.Common.ISession,Spring.Messaging.Ems.Common.IMessageConsumer)">
            <summary>
            Receive a message.
            </summary>
            <param name="session">The session to operate on.</param>
            <param name="consumer">The consumer to receive with.</param>
            <returns>The Message received, or <code>null</code> if none</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveAndConvert">
            <summary> Receive a message synchronously from the default destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            <p>This will only work with a default destination specified!</p>
            </summary>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveAndConvert(TIBCO.EMS.Destination)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destination">the destination to receive a message from
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveAndConvert(System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveSelectedAndConvert(System.String)">
            <summary> Receive a message synchronously from the default destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            <p>This will only work with a default destination specified!</p>
            </summary>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveSelectedAndConvert(TIBCO.EMS.Destination,System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destination">the destination to receive a message from
            </param>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveSelectedAndConvert(System.String,System.String)">
            <summary> Receive a message synchronously from the specified destination, but only
            wait up to a specified time for delivery. Convert the message into an
            object with a configured IMessageConverter.
            <p>This method should be used carefully, since it will block the thread
            until the message becomes available or until the timeout value is exceeded.</p>
            </summary>
            <param name="destinationName">the name of the destination to send this message to
            (to be resolved to an actual destination by a DestinationResolver)
            </param>
            <param name="messageSelector">the EMS message selector expression (or <code>null</code> if none).
            See the EMS specification for a detailed definition of selector expressions.
            </param>
            <returns> the message produced for the consumer or <code>null</code> if the timeout expires.
            </returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Browse(Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in the default EMS queue. The callback gives access to the EMS
            Session and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <returns>the result object from working with the session</returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>        
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Browse(TIBCO.EMS.Queue,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queue">The queue to browse.</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <returns>the result object from working with the session</returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>        
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.Browse(System.String,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queueName">Name of the queue to browse, 
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseSelected(System.String,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseSelected(TIBCO.EMS.Queue,System.String,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queue">The queue to browse.</param>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <returns></returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseSelected(System.String,System.String,Spring.Messaging.Ems.Core.IBrowserCallback)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queueName">Name of the queue to browse, 
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback object that exposes the session/browser pair.</param>
            <returns></returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseWithDelegate(Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in the default EMS queue. The callback gives access to the EMS
            Session and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <returns>the result object from working with the session</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseWithDelegate(TIBCO.EMS.Queue,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queue">The queue to browse.</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <returns>the result object from working with the session</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseWithDelegate(System.String,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queueName">Name of the queue to browse, 
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseSelectedWithDelegate(System.String,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseSelectedWithDelegate(TIBCO.EMS.Queue,System.String,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queue">The queue to browse.</param>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <returns></returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.BrowseSelectedWithDelegate(System.String,System.String,Spring.Messaging.Ems.Core.BrowserDelegate)">
            <summary>
            Browses messages in a EMS queue. The callback gives access to the EMS Session
            and QueueBrowser in order to browse the queue and react to the contents.
            </summary>
            <param name="queueName">Name of the queue to browse, 
            (to be resolved to an actual destination by a DestinationResolver)</param>
            <param name="messageSelector">The EMS message selector expression (or <code>null</code> if none).</param>
            <param name="action">The action callback delegate that exposes the session/browser pair.</param>
            <returns></returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem accessing the EMS API</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.EmsTemplate.CreateBrowser(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Queue,System.String)">
            <summary>
            Creates the queue browser.
            </summary>
            <param name="session">The session.</param>
            <param name="queue">The queue.</param>
            <param name="selector">The selector.</param>
            <returns>A new queue browser</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.DefaultDestination">
            <summary>
            Gets or sets the default destination to be used on send/receive operations that do not
            have a destination parameter.
            </summary>
            <remarks>Alternatively, specify a "defaultDestinationName", to be
            dynamically resolved via the DestinationResolver.</remarks>
            <value>The default destination.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.DefaultDestinationName">
            <summary>
            Gets or sets the name of the default destination name
            to be used on send/receive operations that
            do not have a destination parameter.
            </summary>
            <remarks>
            Alternatively, specify a EMS Destination object as "DefaultDestination"
            </remarks>
            <value>The name of the default destination.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.MessageConverter">
            <summary>
            Gets or sets the message converter for this template.
            </summary>
            <remarks>
            Used to resolve
            Object parameters to convertAndSend methods and Object results
            from receiveAndConvert methods.
            <p>The default converter is a SimpleMessageConverter, which is able
            to handle BytesMessages, TextMessages and ObjectMessages.</p>
            </remarks>
            <value>The message converter.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.MessageIdEnabled">
            <summary>
            Gets or sets a value indicating whether Message Ids are enabled.
            </summary>
            <value><c>true</c> if message id enabled; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.MessageTimestampEnabled">
            <summary>
            Gets or sets a value indicating whether message timestamps are enabled.
            </summary>
            <value>
            	<c>true</c> if [message timestamp enabled]; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.PubSubNoLocal">
             <summary>
             Gets or sets a value indicating whether to inhibit the delivery of messages published by its own connection.
            
             </summary>
             <value><c>true</c> if inhibit the delivery of messages published by its own connection; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.ReceiveTimeout">
            <summary>
            Gets or sets the receive timeout to use for recieve calls.
            </summary>
            <remarks>The default is -1, which means no timeout.</remarks>
            <value>The receive timeout.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.ExplicitQosEnabled">
            <summary>
            Gets or sets a value indicating whether to use explicit Quality of Service values.
            </summary>
            <remarks>If "true", then the values of deliveryMode, priority, and timeToLive
            will be used when sending a message. Otherwise, the default values,
            that may be set administratively, will be used</remarks>
            <value><c>true</c> if use explicit QoS values; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.DeliveryMode">
            <summary>
            Sets a value indicating the delivery mode QOS
            </summary>
            <remarks>
            This will set the delivery to persistent, non-persistent, or reliable delivery.
            Default value is Message.DEFAULT_DELIVERY_MODE (aka TIBCO.EMS.DeliveryMode.PERSISTENT)
            </remarks>
            <value>Integer value representing the delivery mode [delivery persistent]; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.Priority">
            <summary>
            Gets or sets the priority when sending.
            </summary>
            <remarks>Since a default value may be defined administratively,
            this is only used when "isExplicitQosEnabled" equals "true".</remarks>
            <value>The priority.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Core.EmsTemplate.TimeToLive">
            <summary>
            Gets or sets the time to live when sending
            </summary>
            <remarks>Since a default value may be defined administratively,
            this is only used when "isExplicitQosEnabled" equals "true".</remarks>
            <value>The time to live.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.EmsTemplate.EmsTemplateResourceFactory">
            <summary>
            ResourceFactory implementation that delegates to this template's callback methods.
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.ISessionCallback">
            <summary> Callback for executing any number of operations on a provided
            Session
            </summary>
            <remarks>
            <p>To be used with the EmsTemplate.Execute(ISessionCallback)}
            method, often implemented as an anonymous inner class.</p>
            </remarks>
            <author>Mark Pollack</author>
            <seealso cref="M:Spring.Messaging.Ems.Core.EmsTemplate.Execute(Spring.Messaging.Ems.Core.ISessionCallback,System.Boolean)">
            </seealso>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.ISessionCallback.DoInEms(Spring.Messaging.Ems.Common.ISession)">
            <summary> Execute any number of operations against the supplied EMS
            Session, possibly returning a result.
            </summary>
            <param name="session">the EMS <code>Session</code>
            </param>
            <returns> a result object from working with the <code>Session</code>, if any (so can be <code>null</code>) 
            </returns>
            <throws>EMSException if there is any problem </throws>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.IMessageCreator">
            <summary> Creates a EMS message given a Session</summary>
            <remarks>
            <p>The Session typically is provided by an instance
            of the EmsTemplate class.</p>
            </remarks>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IMessageCreator.CreateMessage(Spring.Messaging.Ems.Common.ISession)">
            <summary> Create a Message to be sent.</summary>
            <param name="session">the EMS Session to be used to create the
            <code>Message</code> (never <code>null</code>)
            </param>
            <returns> the <code>Message</code> to be sent
            </returns>
            <throws>EMSException if thrown by EMS API methods </throws>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.SimpleMessageCreator">
            <summary>
            This is a TIBCO specific class so that we can reuse connections, session, and
            message producers instead of creating/destroying them on each operation.
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.IBrowserCallback">
            <summary>
            Callback for browsing the messages in an EMS queue.
            </summary>
            <remarks>
            To be used with EmsTemplate's callback methods that take a IBrowserCallback argument
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IBrowserCallback.DoInEms(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.QueueBrowser)">
            <summary>
            Perform operations on the given Session and QueueBrowser
            </summary>
            <param name="session">The session.</param>
            <param name="browser">The browser.</param>
            <returns>The object from working with the Session and QueueBrowser, may be null</returns>
            <exception cref="T:TIBCO.EMS.EMSException">If there is any problem when accessing EMS API</exception>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.IMessagePostProcessor">
            <summary> To be used with EmsTemplate's send method that
            convert an object to a message.
            </summary>
            <remarks>
            It allows for further modification of the message after it has been processed
            by the converter. This is useful for setting of EMS Header and Properties.
            </remarks>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IMessagePostProcessor.PostProcessMessage(TIBCO.EMS.Message)">
            <summary> Apply a IMessagePostProcessor to the message. The returned message is
            typically a modified version of the original.
            </summary>
            <param name="message">the EMS message from the IMessageConverter
            </param>
            <returns> the modified version of the Message
            </returns>
            <throws>EMSException if thrown by EMS API methods </throws>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.IProducerCallback">
            <summary> Callback for sending a message to a EMS destination.</summary>
            <remarks>
            <p>To be used with the EmsTemplate.Execute(IProducerCallback)
            method, often implemented as an anonymous inner class.</p>
            
            <p>The typical implementation will perform multiple operations on the
            supplied EMS Session and MessageProducer. </p>
            </remarks>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Core.IProducerCallback.DoInEms(Spring.Messaging.Ems.Common.ISession,Spring.Messaging.Ems.Common.IMessageProducer)">
            <summary> Perform operations on the given Session and MessageProducer.
            The message producer is not associated with any destination.
            </summary>
            <param name="session">the EMS <code>Session</code> object to use
            </param>
            <param name="producer">the EMS <code>MessageProducer</code> object to use
            </param>
            <returns> a result object from working with the <code>Session</code>, if any (can be <code>null</code>) 
            </returns>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.MessageCreatorDelegate">
            <summary>
            Delegate that creates a EMS message given a Session
            </summary>
            <param name="session">the EMS Session to be used to create the
            <code>Message</code> (never <code>null</code>) 
            </param>
            <returns> the <code>Message</code> to be sent
            </returns>
            <throws>EMSException if thrown by EMS API methods </throws>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.MessagePostProcessorDelegate">
            <summary>
            Delegate that is used with EmsTemplate's ConvertAndSend method that converts
            an object.
            </summary>
            <remarks>
            It allows for further modification of the message after it has been processed
            by the converter. This is useful for setting of EMS Header and Properties.
            </remarks>
            <author>Mark Pollack</author>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.ProducerDelegate">
            <summary> Perform operations on the given Session and MessageProducer.
            The message producer is not associated with any destination.
            </summary>
            <param name="session">the EMS <code>Session</code> object to use
            </param>
            <param name="producer">the EMS <code>MessageProducer</code> object to use
            </param>
            <returns> a result object from working with the <code>Session</code>, if any (can be <code>null</code>) 
            </returns>
        </member>
        <member name="T:Spring.Messaging.Ems.Core.SessionDelegate">
            <summary>
            Callback delegate for code that operates on a Session. 
            </summary>
            <param name="session">The EMS Session object.</param>
            <remarks>
            <para>Allows you to execute any number of operations
            on a single ISession, possibly returning a result a result.
            </para>
            </remarks>
            <returns>A result object from working with the <code>Session</code>, if any (so can be <code>null</code>) 
            </returns>
            <throws>EMSException if there is any problem </throws>
            <author>Mark Pollack</author>
        </member>
        <member name="T:Spring.Messaging.Ems.Jndi.JndiAccessor">
            <summary>
            Convenient superclass to access JndiProperties, JndiContextType or alternatively set the ILookupContext directly.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Jndi.JndiAccessor.AfterPropertiesSet">
            <summary>
            Create the JndiLookupContext if it has not been explicitly set.
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiAccessor.JndiLookupContext">
            <summary>
            Gets or sets the lookup context.
            </summary>
            <value>The lookup context.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiAccessor.JndiProperties">
            <summary>
            Gets or sets the JNDI environment properties.
            </summary>
            <value>The jndi properties.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiAccessor.JndiContextType">
            <summary>
            Gets or sets the type of the jndi context.  The default is JndiContextType.JMS
            </summary>
            <value>The type of the jndi context.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Jndi.JndiContextType">
            <summary>
            The various JNDI Context types.
            </summary>
        </member>
        <member name="F:Spring.Messaging.Ems.Jndi.JndiContextType.JMS">
            <summary>
            Create a tibjmsnaming context to lookup administered object inside the tibjmsnaming server. 
            </summary>
        </member>
        <member name="F:Spring.Messaging.Ems.Jndi.JndiContextType.LDAP">
            <summary>
            Create a ldap context to lookup administered object in an ldap server. 
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Jndi.JndiObjectLocator">
            <summary>
            Convenient superclass for JNDI-based service locators, 
            providing configurable lookup of a specific JNDI resource.
            </summary>
            <remarks>
            <para>
            Exposes a JndiName property.
            </para>
            <para>Subclasses may invoke the <code>Lookup</code> method whenever it is appropriate.
            Some classes might do this on initialization, while others might do it
            on demand. The latter strategy is more flexible in that it allows for
            initialization of the locator before the JNDI object is available.
            </para>
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Jndi.JndiObjectLocator.AfterPropertiesSet">
            <summary>
            Ensure that the JndiName property is set and create the TIBCO EMS ILookupContext instance.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Jndi.JndiObjectLocator.Lookup">
            <summary>
            Lookups this instance using the JndiName and ExpectedType properties
            </summary>
            <returns>The object retrieved from Jndi</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiObjectLocator.JndiName">
            <summary>
            Gets or sets the Jndi name to lookup.
            </summary>
            <value>The name of the jndi.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiObjectLocator.ExpectedType">
            <summary>
            Gets or sets the type that the located JNDI object is supposed 
            to be assignable to, if any.
            </summary>
            <value>The expected type.</value>
        </member>
        <member name="M:Spring.Messaging.Ems.Jndi.JndiLookupFactoryObject.GetObject">
            <summary>
            Return the Jndi object
            </summary>
            <returns>The Jndi  object</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiLookupFactoryObject.DefaultObject">
            <summary>
            Sets the default object to fall back to if the JNDI lookup fails.
            Default is none.
            </summary>
            <remarks>
            <para>This can be an arbitrary bean reference or literal value.
            It is typically used for literal values in scenarios where the JNDI environment
            might define specific config settings but those are not required to be present.
            </para>
            </remarks>
            <value>The default object to use when lookup fails.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiLookupFactoryObject.ObjectType">
            <summary>
            Return type of object retrieved from Jndi or the expected type if the Jndi retrieval
            did not succeed.
            </summary>
            <value>Return value of retrieved object</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiLookupFactoryObject.IsSingleton">
            <summary>
            Returns true
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.JndiLookupFactoryObject.ProductTemplate">
            <summary>
            Gets the template object definition that should be used
            to configure the instance of the object managed by this factory.
            </summary>
            <value></value>
        </member>
        <member name="T:Spring.Messaging.Ems.Jndi.LookupContextFactoryObject">
            <summary>
            A Spring FactoryObject that returns TIBCO.EMS.ILookupContext.  Use the returned
            ILookupContext to do you lookups at runtime.
            </summary>
            <remarks>
            <para>
            Important properties to set are JndiProperties and JndiContexType.  JndiContextType is set to
            LookupContextFactory.TIBJMS_NAMING_CONT by default.
            </para>
            <para>To lookup objects at startup time and cache their values, as well as provide a 
            default value if lookup fail, <see cref="T:Spring.Messaging.Ems.Jndi.JndiLookupFactoryObject"/>
            </para>
            </remarks>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Jndi.LookupContextFactoryObject.GetObject">
            <summary>
            Returns the TIBCO.EMS.ILookupContext
            </summary>
            <returns>TIBCO.EMS.ILookupContext</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.LookupContextFactoryObject.ObjectType">
            <summary>
            Return typeof(TIBCO.EMS.ILookupContext)
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Jndi.LookupContextFactoryObject.IsSingleton">
            <summary>
            Returns true
            </summary>
        </member>
        <member name="T:Spring.Objects.Factory.TypeMismatchNamingException">
            <summary>
            Exception thrown if a type mismatch is encountered for an object
            located in a JNDI environment. 
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Objects.Factory.TypeMismatchNamingException.#ctor(System.String)">
            <summary>
            Creates a new instance of the 
            <see cref="T:Spring.Objects.Factory.ObjectCreationException"/> class.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
        </member>
        <member name="M:Spring.Objects.Factory.TypeMismatchNamingException.#ctor(System.String,System.Type,System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Objects.Factory.TypeMismatchNamingException"/> class 
            building an explanation text from the given arguments.
            </summary>
            <param name="jndiName">The Jndi name.</param>
            <param name="requiredType">Type required type of the lookup.</param>
            <param name="actualType">The actual type that the lookup returned.</param>
        </member>
        <member name="P:Spring.Objects.Factory.TypeMismatchNamingException.ActualType">
            <summary>
            Gets the actual type that the lookup returned, if available.
            </summary>
            <value>The actual type that the lookup.</value>
        </member>
        <member name="P:Spring.Objects.Factory.TypeMismatchNamingException.RequiredType">
            <summary>
            Gets the required type for the lookup, if available.
            </summary>
            <value>The equired type for the lookup</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.Adapter.ListenerExecutionFailedException">
            <summary>
            Exception to be thrown when the execution of a listener method failed.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.ListenerExecutionFailedException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Listener.Adapter.ListenerExecutionFailedException"/> class, with the specified message
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.ListenerExecutionFailedException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Listener.Adapter.ListenerExecutionFailedException"/> class, with the specified message
            and root cause exception
            </summary>
            <param name="message">The message.</param>
            <param name="innerException">The inner exception.</param>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter">
            <summary>
            Message listener adapter that delegates the handling of messages to target
            listener methods via reflection, with flexible message type conversion.
            Allows listener methods to operate on message content types, completely
            independent from the EMS API.
            </summary>
            <remarks>
            <para>By default, the content of incoming messages gets extracted before
            being passed into the target listener method, to let the target method
            operate on message content types such as String or byte array instead of
            the raw Message. Message type conversion is delegated to a Spring
            <see cref="T:Spring.Messaging.Ems.Support.Converter.IMessageConverter"/>. By default, a <see cref="T:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter"/>
            will be used. (If you do not want such automatic message conversion taking
            place, then be sure to set the <see cref="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.MessageConverter"/> property
            to <code>null</code>.)
            </para>
            <para>If a target listener method returns a non-null object (typically of a
            message content type such as <code>String</code> or byte array), it will get
            wrapped in a EMS <code>Message</code> and sent to the response destination
            (either the EMS "reply-to" destination or the <see cref="F:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.defaultResponseDestination"/>
            specified.
            </para>
            <para>
            The sending of response messages is only available when
            using the <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/> entry point (typically through a
            Spring message listener container). Usage as standard EMS MessageListener
            does <i>not</i> support the generation of response messages.
            </para>
            <para>Consult the reference documentation for examples of method signatures compliant with this
            adapter class.
            </para>
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener">
            <summary>
            Variant of the standard EMS MessageListener interface,
            offering not only the received Message but also the underlying
            Session object. The latter can be used to send reply messages,
            without the need to access an external Connection/Session,
            i.e. without the need to access the underlying ConnectionFactory.
            </summary>
            <remarks>
            Supported by Spring's <see cref="T:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer"/>
            as direct alternative to the standard MessageListener interface.
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener.OnMessage(TIBCO.EMS.Message,Spring.Messaging.Ems.Common.ISession)">
            <summary> Callback for processing a received EMS message.
            Implementors are supposed to process the given Message,
            typically sending reply messages through the given Session.
            </summary>
            <param name="message">the received EMS message
            </param>
            <param name="session">the underlying EMS Session
            </param>
            <throws>  EMSException if thrown by EMS methods </throws>
        </member>
        <member name="F:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.ORIGINAL_DEFAULT_HANDLER_METHOD">
            <summary>
            The default handler method name.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter"/> class with default settings.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.#ctor(System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter"/> class for the given handler object
            </summary>
            <param name="handlerObject">The delegate object.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.OnMessage(TIBCO.EMS.Message)">
            <summary>
            Standard JMS {@link MessageListener} entry point.
            <para>Delegates the message to the target listener method, with appropriate
            conversion of the message arguments
            </para>
            </summary>
            <remarks>
            In case of an exception, the <see cref="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.HandleListenerException(System.Exception)"/> method will be invoked.
            <b>Note</b> 
            Does not support sending response messages based on
            result objects returned from listener methods. Use the
            <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/> entry point (typically through a Spring
            message listener container) for handling result objects as well.
            </remarks>
            <param name="message">The incoming message.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.OnMessage(TIBCO.EMS.Message,Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Spring <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/> entry point.
            <para>
            Delegates the message to the target listener method, with appropriate
            conversion of the message argument. If the target method returns a
            non-null object, wrap in a EMS message and send it back.
            </para>
            </summary>
            <param name="message">The incoming message.</param>
            <param name="session">The session to operate on.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.InitDefaultStrategies">
            <summary>
            Initialize the default implementations for the adapter's strategies.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.HandleListenerException(System.Exception)">
            <summary>
            Handle the given exception that arose during listener execution.
            The default implementation logs the exception at error level.
            <para>This method only applies when used as standard EMS MessageListener.
            In case of the Spring <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/> mechanism,
            exceptions get handled by the caller instead.
            </para>
            </summary>
            <param name="ex">The exception to handle.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.ExtractMessage(TIBCO.EMS.Message)">
            <summary>
            Extract the message body from the given message.
            </summary>
            <param name="message">The message.</param>
            <returns>the content of the message, to be passed into the
            listener method as argument</returns>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by EMS API methods</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.GetHandlerMethodName(TIBCO.EMS.Message,System.Object)">
            <summary>
            Gets the name of the listener method that is supposed to
            handle the given message.
            The default implementation simply returns the configured
            default listener method, if any.
            </summary>
            <param name="originalMessage">The EMS request message.</param>
            <param name="extractedMessage">The converted JMS request message,
            to be passed into the listener method as argument.</param>
            <returns>the name of the listener method (never <code>null</code>)</returns>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by EMS API methods</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.HandleResult(System.Object,TIBCO.EMS.Message,Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Handles the given result object returned from the listener method, sending a response message back. 
            </summary>
            <param name="result">The result object to handle (never <code>null</code>).</param>
            <param name="request">The original request message.</param>
            <param name="session">The session to operate on (may be <code>null</code>).</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.BuildMessage(Spring.Messaging.Ems.Common.ISession,System.Object)">
            <summary>
            Builds a JMS message to be sent as response based on the given result object.
            </summary>
            <param name="session">The JMS Session to operate on.</param>
            <param name="result">The content of the message, as returned from the listener method.</param>
            <returns>the JMS <code>Message</code> (never <code>null</code>)</returns>
            <exception cref="T:Spring.Messaging.Ems.Support.Converter.MessageConversionException">If there was an error in message conversion</exception>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by EMS API methods</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.PostProcessResponse(TIBCO.EMS.Message,TIBCO.EMS.Message)">
            <summary>
            Post-process the given response message before it will be sent. The default implementation
            sets the response's correlation id to the request message's correlation id.
            </summary>
            <param name="request">The original incoming message.</param>
            <param name="response">The outgoing JMS message about to be sent.</param>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by EMS API methods</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.GetResponseDestination(TIBCO.EMS.Message,TIBCO.EMS.Message,Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Determine a response destination for the given message.
            </summary>
            <remarks>
            <para>The default implementation first checks the JMS Reply-To
            Destination of the supplied request; if that is not <code>null</code>
            it is returned; if it is <code>null</code>, then the configured
            <see cref="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.DefaultResponseDestination"/> default response destination}
            is returned; if this too is <code>null</code>, then an
            <see cref="T:TIBCO.EMS.InvalidDestinationException"/>is thrown.
            </para>
            </remarks>
            <param name="request">The original incoming message.</param>
            <param name="response">Tthe outgoing message about to be sent.</param>
            <param name="session">The session to operate on.</param>
            <returns>the response destination (never <code>null</code>)</returns>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by EMS API methods</exception>
            <exception cref="T:TIBCO.EMS.InvalidDestinationException">if no destination can be determined.</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.ResolveDefaultResponseDestination(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Resolves the default response destination into a Destination, using this
            accessor's <see cref="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.DestinationResolver"/> in case of a destination name.
            </summary>
            <param name="session">The session to operate on.</param>
            <returns>The located destination</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.SendResponse(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination,TIBCO.EMS.Message)">
            <summary>
            Sends the given response message to the given destination.
            </summary>
            <param name="session">The session to operate on.</param>
            <param name="destination">The destination to send to.</param>
            <param name="response">The outgoing message about to be sent.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.PostProcessProducer(Spring.Messaging.Ems.Common.IMessageProducer,TIBCO.EMS.Message)">
            <summary>
            Post-process the given message producer before using it to send the response.
            The default implementation is empty.
            </summary>
            <param name="producer">The producer that will be used to send the message.</param>
            <param name="response">The outgoing message about to be sent.</param>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.HandlerObject">
            <summary>
            Gets or sets the handler object to delegate message listening to.
            </summary>
            <remarks>
            Specified listener methods have to be present on this target object.
            If no explicit handler object has been specified, listener
            methods are expected to present on this adapter instance, that is,
            on a custom subclass of this adapter, defining listener methods.
            </remarks>
            <value>The handler object.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.DefaultHandlerMethod">
            <summary>
            Gets or sets the default handler method to delegate to,
            for the case where no specific listener method has been determined.
            Out-of-the-box value is <see cref="F:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.ORIGINAL_DEFAULT_HANDLER_METHOD"/> ("HandleMessage"}.
            </summary>
            <value>The default handler method.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.DefaultResponseDestination">
            <summary>
            Sets the default destination to send response messages to. This will be applied
            in case of a request message that does not carry a "JMSReplyTo" field.
            Response destinations are only relevant for listener methods that return
            result objects, which will be wrapped in a response message and sent to a
            response destination.
            <para>
            Alternatively, specify a "DefaultResponseQueueName" or "DefaultResponseTopicName",
            to be dynamically resolved via the DestinationResolver.
            </para>
            </summary>
            <value>The default response destination.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.DefaultResponseQueueName">
            <summary>
            Sets the name of the default response queue to send response messages to.
            This will be applied in case of a request message that does not carry a
            "EMSReplyTo" field.
            <para>Alternatively, specify a JMS Destination object as "defaultResponseDestination".</para>
            </summary>
            <value>The name of the default response destination queue.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.DefaultResponseTopicName">
            <summary>
            Sets the name of the default response topic to send response messages to.
            This will be applied in case of a request message that does not carry a
            "ReplyTo" field.
            <para>Alternatively, specify a JMS Destination object as "defaultResponseDestination".</para>
            </summary>
            <value>The name of the default response destination topic.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.DestinationResolver">
            <summary>
            Gets or sets the destination resolver that should be used to resolve response
            destination names for this adapter.
            <para>The default resolver is a <see cref="T:Spring.Messaging.Ems.Support.Destinations.DynamicDestinationResolver"/>.
            Specify another implementation, for other strategies, perhaps from a directory service.</para>
            </summary>
            <value>The destination resolver.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.Adapter.MessageListenerAdapter.MessageConverter">
            <summary>
            Gets or sets the message converter that will convert incoming JMS messages to
            listener method arguments, and objects returned from listener
            methods back to EMS messages.
            </summary>
            <remarks>
            <para>The default converter is a {@link SimpleMessageConverter}, which is able
            to handle BytesMessages}, TextMessages, MapMessages, and ObjectMessages.
            </para>
            </remarks>
            <value>The message converter.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.Adapter.DestinationNameHolder">
            <summary>
            Internal class combining a destination name and its target destination type (queue or topic).
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.AbstractListenerContainer">
             <summary>
             Common base class for all containers which need to implement listening
             based on a Connection (either shared or freshly obtained for each attempt).
             Inherits basic Connection and Session configuration handling from the
             <see cref="T:Spring.Messaging.Ems.Support.EmsAccessor"/> base class.
             </summary>
             <para>
             This class provides basic lifecycle management, in particular management
             of a shared Connection. Subclasses are supposed to plug into this
             lifecycle, implementing the <see cref="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.SharedConnectionEnabled"/> as well as
            
             </para>
             <remarks>
            
             </remarks>
             <author>Mark Pollack</author>
        </member>
        <member name="F:Spring.Messaging.Ems.Listener.AbstractListenerContainer.sharedConnectionMonitor">
            <summary>
            The monitor object to lock on when performing operations on the connection.
            </summary>
        </member>
        <member name="F:Spring.Messaging.Ems.Listener.AbstractListenerContainer.lifecycleMonitor">
            <summary>
            The monitor object to lock on when performing operations that update the lifecycle of the container.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.AfterPropertiesSet">
            <summary>
            Call base class method, then <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.ValidateConfiguration"/> and then <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Initialize"/>
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.ValidateConfiguration">
            <summary>
            Validates the configuration of this container.  The default implementation
            is empty.  To be overriden in subclasses.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Dispose">
            <summary>
            Calls <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Shutdown"/> when the application context destroys the container instance.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Initialize">
            <summary>
            Initializes this container.  Creates a Connection, starts the Connection
            (if the property <see cref="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.AutoStartup"/> hasn't been turned off), and calls
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.DoInitialize"/>.
            </summary>
            <exception cref="T:TIBCO.EMS.EMSException">If startup failed</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Shutdown">
            <summary>
            Stop the shared connection, call <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.DoShutdown"/>, and close this container.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Start">
            <summary>
            Starts this container.
            </summary>
            <exception cref="T:TIBCO.EMS.EMSException">if starting failed.</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.DoStart">
            <summary>
            Start the shared Connection, if any, and notify all invoker tasks.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Stop">
            <summary>
            Stops this container.
            </summary>
            <exception cref="T:TIBCO.EMS.EMSException">if stopping failed.</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.DoStop">
            <summary>
            Notify all invoker tasks and stop the shared Connection, if any.
            </summary>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by EMS API methods.</exception>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.StopSharedConnection"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.DoInitialize">
            <summary>
            Register any invokers within this container.
            Subclasses need to implement this method for their specific
            invoker management process.  A shared Connection, if any, will already have been
            started at this point.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.DoShutdown">
            <summary>
            Close the registered invokers.  Subclasses need to implement this method
            for their specific invoker management process. A shared Connection, if any,
            will automatically be closed afterwards.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.EstablishSharedConnection">
            <summary>
            Establishes a shared Connection for this container.
            </summary>
            <remarks>
            <para>
            The default implementation delegates to <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.CreateSharedConnection"/>
            which does one immediate attempt and throws an exception if it fails.
            Can be overridden to have a recovery process in place, retrying
            until a Connection can be successfully established.
            </para>
            </remarks>
            <exception cref="T:TIBCO.EMS.EMSException">If thrown by EMS API methods</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.RefreshSharedConnection">
            <summary>
            Refreshes the shared connection that this container holds.
            </summary>
            <remarks>
            Called on startup and also after an infrastructure exception
            that occurred during invoker setup and/or execution.
            </remarks>
            <exception cref="T:TIBCO.EMS.EMSException">If thrown by EMS API methods</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.CreateSharedConnection">
            <summary>
            Creates the shared connection for this container.
            </summary>
            <remarks>
            The default implementation creates a standard Connection
            and prepares it through <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.PrepareSharedConnection(Spring.Messaging.Ems.Common.IConnection)"/>
            </remarks>
            <returns>the prepared Connection</returns>
            <exception cref="T:TIBCO.EMS.EMSException">if the creation failed.</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.PrepareSharedConnection(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Prepares the given connection, which is about to be registered
            as shared Connection for this container.
            </summary>
            <remarks>
            The default implementation sets the specified client id, if any.
            Subclasses can override this to apply further settings.
            </remarks>
            <param name="connection">The connection to prepare.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If the preparation efforts failed.</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.StartSharedConnection">
            <summary>
            Starts the shared connection.
            </summary>
            <exception cref="T:TIBCO.EMS.EMSException">If thrown by EMS API methods</exception>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Start"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.StopSharedConnection">
            <summary>
            Stops the shared connection.
            </summary>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by EMS API methods.</exception>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.ClientId">
            <summary>
            Gets or sets the client id for a shared Connection created and used by this container.
            </summary>
            <remarks>
            Note that client ids need to be unique among all active Connections
            of the underlying JMS provider. Furthermore, a client id can only be
            assigned if the original ConnectionFactory hasn't already assigned one.
            </remarks>
            <value>The client id.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.AutoStartup">
            <summary> Set whether to automatically start the listener after initialization.
            <p>Default is "true"; set this to "false" to allow for manual startup.</p>
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.ObjectName">
            <summary>
            Set the name of the object in the object factory that created this object.
            </summary>
            <value>The name of the object in the factory.</value>
            <remarks>
            	<p>
            Invoked after population of normal object properties but before an init
            callback like <see cref="T:Spring.Objects.Factory.IInitializingObject"/>'s
            <see cref="M:Spring.Objects.Factory.IInitializingObject.AfterPropertiesSet"/>
            method or a custom init-method.
            </p>
            </remarks>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.IsRunning">
            <summary>
            Gets a value indicating whether this container is currently running,
            that is, whether it has been started and not stopped yet.
            </summary>
            <value>
            	<c>true</c> if this container is running; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.RunningAllowed">
            <summary>
            Gets a value indicating whether this container's listeners are generally allowed to run.
            </summary>
            <remarks>
            <para>
            &gt;This implementation always returns <code>true</code>; the default 'running'
            state is purely determined by <see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Start"/>/<see cref="M:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Stop"/>.
            </para>
            <para>
            Subclasses may override this method to check against temporary
            conditions that prevent listeners from actually running. In other words,
            they may apply further restrictions to the 'running' state, returning
            <code>false</code> if such a restriction prevents listeners from running.
            </para>
            </remarks>
            <value><c>true</c> if running allowed; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.Active">
            <summary>
            Gets a value indicating whether	this container is currently active,
            that is, whether it has been set up but not shut down yet.
            </summary>
            <value><c>true</c> if active; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.SharedConnectionEnabled">
            <summary> Return whether a shared EMS Connection should be maintained
            by this listener container base class.
            </summary>     
            <seealso cref="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.SharedConnection"/>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.SharedConnection">
            <summary>
            Gets the shared connection maintained by this container.
            Available after initialization.
            </summary>
            <value>The shared connection (never null)</value>
            <exception cref="T:System.InvalidOperationException">if this container does not maintain a
            shared Connection, or if the Connection hasn't been initialized yet.
            </exception>
            <see cref="P:Spring.Messaging.Ems.Listener.AbstractListenerContainer.SharedConnectionEnabled"/>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.SharedConnectionNotInitializedException">
            <summary>
            Exception that indicates that the initial setup of this container's
            shared Connection failed. This is indicating to invokers that they need
            to establish the shared Connection themselves on first access.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SharedConnectionNotInitializedException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Listener.SharedConnectionNotInitializedException"/> class.
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer">
            <summary>
            Abstract base class for message listener containers. Can either host
            a standard EMS MessageListener or a Spring-specific
            <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/>
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.ValidateConfiguration">
            <summary>
            Validate that the destination is not null and that if the subscription is durable, then we are not
            using the Pub/Sub domain.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.ExecuteListener(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)">
            <summary>
            Executes the specified listener, 
            committing or rolling back the transaction afterwards (if necessary).
            </summary>
            <param name="session">The session to operate on.</param>
            <param name="message">The received message.</param>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.InvokeListener(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)"/>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.CommitIfNecessary(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)"/>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.RollbackOnExceptionIfNecessary(Spring.Messaging.Ems.Common.ISession,System.Exception)"/>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.HandleListenerException(System.Exception)"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.DoExecuteListener(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)">
            <summary>
            Executes the specified listener, 
            committing or rolling back the transaction afterwards (if necessary).
            </summary>
            <param name="session">The session to operate on.</param>
            <param name="message">The received message.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If thrown by EMS API methods.</exception>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.InvokeListener(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)"/>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.CommitIfNecessary(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)"/>
            <see cref="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.RollbackOnExceptionIfNecessary(Spring.Messaging.Ems.Common.ISession,System.Exception)"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.InvokeListener(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)">
            <summary>
            Invokes the specified listener: either as standard EMS MessageListener
            or (preferably) as Spring ISessionAwareMessageListener.
            </summary>
            <param name="session">The session to operate on.</param>
            <param name="message">The received message.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If thrown by EMS API methods.</exception>
            <see cref="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.MessageListener"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.DoInvokeListener(Spring.Messaging.Ems.Listener.ISessionAwareMessageListener,Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)">
            <summary>
            Invoke the specified listener as Spring ISessionAwareMessageListener,
            exposing a new EMS Session (potentially with its own transaction)
            to the listener if demanded.
            </summary>
            <param name="listener">The Spring ISessionAwareMessageListener to invoke.</param>
            <param name="session">The session to operate on.</param>
            <param name="message">The received message.</param>
            <exception cref="T:TIBCO.EMS.EMSException">If thrown by EMS API methods.</exception>
            <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/>
            <see cref="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.ExposeListenerSession"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.DoInvokeListener(TIBCO.EMS.IMessageListener,TIBCO.EMS.Message)">
            <summary>
            Invoke the specified listener as standard JMS MessageListener.
            </summary>
            <remarks>Default implementation performs a plain invocation of the
            <code>OnMessage</code> methods</remarks>
            <param name="listener">The listener to invoke.</param>
            <param name="message">The received message.</param>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by the EMS API methods</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.CommitIfNecessary(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Message)">
            <summary>
            Perform a commit or message acknowledgement, as appropriate
            </summary>
            <param name="session">The session to commit.</param>
            <param name="message">The message to acknowledge.</param>
            <exception cref="T:TIBCO.EMS.EMSException">In case of commit failure</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.IsSessionLocallyTransacted(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Determines whether the given Session is locally transacted, that is, whether
            its transaction is managed by this listener container's Session handling
            and not by an external transaction coordinator.
            </summary>
            <remarks>
            The Session's own transacted flag will already have been checked
            before. This method is about finding out whether the Session's transaction
            is local or externally coordinated.
            </remarks>
            <param name="session">The session to check.</param>
            <returns>
            	<c>true</c> if the is session locally transacted; otherwise, <c>false</c>.
            </returns>
            <see cref="P:Spring.Messaging.Ems.Support.EmsAccessor.SessionTransacted"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.RollbackIfNecessary(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Perform a rollback, if appropriate.
            </summary>
            <param name="session">The session to rollback.</param>
            <exception cref="T:TIBCO.EMS.EMSException">In case of a rollback error</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.RollbackOnExceptionIfNecessary(Spring.Messaging.Ems.Common.ISession,System.Exception)">
            <summary>
            Perform a rollback, handling rollback excepitons properly.
            </summary>
            <param name="session">The session to rollback.</param>
            <param name="ex">The thrown application exception.</param>
            <exception cref="T:TIBCO.EMS.EMSException">in case of a rollback error.</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.HandleListenerException(System.Exception)">
            <summary>
            Handle the given exception that arose during listener execution.
            </summary>
            <remarks>
            The default implementation logs the exception at error level,
            not propagating it to the JMS provider - assuming that all handling of
            acknowledgement and/or transactions is done by this listener container.
            This can be overridden in subclasses.
            </remarks>
            <param name="ex">The exceptin to handle</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.InvokeExceptionListener(TIBCO.EMS.EMSException)">
            <summary>
            Invokes the registered exception listener, if any.
            </summary>
            <param name="ex">The exception that arose during EMS processing.</param>
            <see cref="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.ExceptionListener"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.CheckMessageListener(System.Object)">
            <summary>
            Checks the message listener, throwing an exception
            if it does not correspond to a supported listener type.
            By default, only a standard JMS MessageListener object or a
            Spring <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/> object will be accepted.
            </summary>
            <param name="messageListener">The message listener.</param>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.Destination">
            <summary>
            Gets or sets the destination to receive messages from. Will be <code>null</code>
            if the configured destination is not an actual Destination type;
            c.f. <see cref="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.DestinationName"/> when the destination is a String.
            </summary>
            <value>The destination.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.DestinationName">
            <summary>
            Gets or sets the name of the destination to receive messages from.
            Will be <code>null</code> if the configured destination is not a
            string  type; c.f. <see cref="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.Destination"/> when it is an actual Destination object.
            </summary>
            <value>The name of the destination.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.MessageSelector">
            <summary>
            Gets or sets the message selector.
            </summary>
            <value>The message selector expression (or <code>null</code> if none)..</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.MessageListener">
            <summary>
            Gets or sets the message listener to register.
            </summary>
            
            <remarks>
            <para>
            This can be either a standard EMS MessageListener object or a 
            Spring <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/> object.
            </para>
            </remarks>
            <value>The message listener.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.SubscriptionDurable">
            <summary>
            Gets or sets a value indicating whether the subscription is durable.
            </summary>
            <remarks>
            Set whether to make the subscription durable. The durable subscription name
            to be used can be specified through the "DurableSubscriptionName" property.
            <para>Default is "false". Set this to "true" to register a durable subscription,
            typically in combination with a "DurableSubscriptionName" value (unless
            your message listener class name is good enough as subscription name).
            </para>
            <para>Only makes sense when listening to a topic (pub-sub domain).</para>
            </remarks>
            <value><c>true</c> if the subscription is durable; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.DurableSubscriptionName">
            <summary>
            Gets or sets the name of the durable subscription to create.
            </summary>
            <remarks>
            To be applied in case of a topic (pub-sub domain) with subscription durability activated.
            The durable subscription name needs to be unique within this client's
            client id. Default is the class name of the specified message listener.
            <para>Note: Only 1 concurrent consumer (which is the default of this
            message listener container) is allowed for each durable subscription.
            </para> 	   
            </remarks>
            <value>The name of the durable subscription.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.ExceptionListener">
            <summary>
            Gets or sets the exception listener to notify in case of a EMSException thrown
            by the registered message listener or the invocation infrastructure.
            </summary>
            <value>The exception listener.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.ErrorHandler">
            <summary>
            Sets an ErrorHandler to be invoked in case of any uncaught exceptions thrown
            while processing a Message. By default there will be no ErrorHandler
            so that error-level logging is the only result.
            </summary>
            <value>The error handler.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.ExposeListenerSession">
            <summary>
            Gets or sets a value indicating whether to expose listener session to a registered
            <see cref="T:Spring.Messaging.Ems.Listener.ISessionAwareMessageListener"/> as well as to <see cref="T:Spring.Messaging.Ems.Core.EmsTemplate"/> calls.
            </summary>
            <remarks>
            Default is "true", reusing the listener's Session.
            Turn this off to expose a fresh Session fetched from the same
            underlying Connection instead, which might be necessary
            on some messaging providers.
            <para>Note that Sessions managed by an external transaction manager will
            always get exposed to <see cref="T:Spring.Messaging.Ems.Core.EmsTemplate"/>
            calls. So in terms of EmsTemplate exposure, this setting only affects
            locally transacted Sessions.
            </para>
            </remarks>
            <value>
            	<c>true</c> if expose listener session; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.AbstractMessageListenerContainer.AcceptMessagesWhileStopping">
            <summary>
            Gets or sets a value indicating whether to accept messages while
            the listener container is in the process of stopping.
            </summary>
            <remarks>
            <para>
            Return whether to accept received messages while the listener container
            receive attempt. Switch this flag on to fully process such messages
            even in the stopping phase, with the drawback that even newly sent
            messages might still get processed (if coming in before all receive
            timeouts have expired).
            </para>
            <para>
            Aborting receive attempts for such incoming messages
            might lead to the provider's retry count decreasing for the affected
            messages. If you have a high number of concurrent consumers, make sure
            that the number of retries is higher than the number of consumers,
            to be on the safe side for all potential stopping scenarios.
            </para>
            </remarks>
            <value>
            	<c>true</c> if accept messages while in the process of stopping; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.MessageRejectedWhileStoppingException">
            <summary>
            Internal exception class that indicates a rejected message on shutdown.
            Used to trigger a rollback for an external transaction manager in that case.
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.LocallyExposedEmsResourceHolder">
            <summary>
            EmsResourceHolder marker subclass that indicates local exposure,
            i.e. that does not indicate an externally managed transaction.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.LocallyExposedEmsResourceHolder.#ctor(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Listener.LocallyExposedEmsResourceHolder"/> class.
            </summary>
            <param name="session">The session.</param>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.RecoveryTimeExceededException">
            <summary>
            Exception thrown when the maximum connection recovery time has been exceeded.
            </summary>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.RecoveryTimeExceededException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Listener.RecoveryTimeExceededException"/> class, with the specified message
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.RecoveryTimeExceededException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Listener.Adapter.ListenerExecutionFailedException"/> class, with the specified message
            and root cause exception
            </summary>
            <param name="message">The message.</param>
            <param name="innerException">The inner exception.</param>
        </member>
        <member name="T:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer">
            <summary>
            Message listener container that uses the plain EMS client API's
            MessageConsumer.Listener method to create concurrent
            MessageConsumers for the specified listeners.
            </summary>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="F:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.DEFAULT_RECOVERY_INTERVAL">
            <summary>
            The default recovery time interval between connection reconnection attempts
            </summary>
        </member>
        <member name="F:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.DEFAULT_MAX_RECOVERY_TIME">
            <summary>
            The total time connection recovery will be attempted.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.ValidateConfiguration">
            <summary>
            Call base class for valdation and then check that if the subscription is durable that the number of 
            concurrent consumers is equal to one.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.DoInitialize">
            <summary>
            Creates the specified number of concurrent consumers,
            in the form of a JMS Session plus associated MessageConsumer
            </summary>
            <see cref="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.CreateListenerConsumer(Spring.Messaging.Ems.Common.ISession)"/>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.DoStart">
            <summary>
            Re-initializes this container's EMS message consumers,
            if not initialized already.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.PrepareSharedConnection(Spring.Messaging.Ems.Common.IConnection)">
            <summary>
            Registers this listener container as EMS ExceptionListener on the shared connection.
            </summary>
            <param name="connection"></param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.OnException(TIBCO.EMS.EMSException)">
            <summary>
            <see cref="T:TIBCO.EMS.IExceptionListener"/> implementation, invoked by the EMS provider in
            case of connection failures. Re-initializes this listener container's
            shared connection and its sessions and consumers.
            </summary>
            <param name="exception">The reported connection exception.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.RefreshConnectionUntilSuccessful">
            <summary>
            Refresh the underlying Connection, not returning before an attempt has been
            successful. Called in case of a shared Connection as well as without shared
            Connection, so either needs to operate on the shared Connection or on a
            temporary Connection that just gets established for validation purposes.
            </summary>
            <remarks>
            The default implementation retries until it successfully established a
            Connection, for as long as this message listener container is active.
            Applies the specified recovery interval between retries.
            </remarks>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.SleepInBetweenRecoveryAttempts">
            <summary>
            The amount of time to sleep in between recovery attempts.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.InitializeConsumers">
            <summary>
            Initialize the Sessions and MessageConsumers for this container.
            </summary>
            <exception cref="T:TIBCO.EMS.EMSException">in case of setup failure.</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.CreateListenerConsumer(Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Creates a MessageConsumer for the given Session,
            registering a MessageListener for the specified listener
            </summary>
            <param name="session">The session to work on.</param>
            <returns>the MessageConsumer"/&gt;</returns>
            <exception cref="T:TIBCO.EMS.EMSException">if thrown by EMS methods</exception>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.DoShutdown">
            <summary>
            Close the message consumers and sessions.
            </summary>
            <throws>EMSException if destruction failed </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.CreateConsumer(Spring.Messaging.Ems.Common.ISession,TIBCO.EMS.Destination)">
            <summary>
            Creates a MessageConsumer for the given Session and Destination.
            </summary>
            <param name="session">The session to create a MessageConsumer for.</param>
            <param name="destination">The destination to create a MessageConsumer for.</param>
            <returns>The new MessageConsumer</returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.PubSubNoLocal">
            <summary>
            Gets or sets a value indicating whether to inhibit the delivery of messages published by its own connection.
            Default is "false".
            </summary>
            <value><c>true</c> if should inhibit the delivery of messages published by its own connection; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.ConcurrentConsumers">
            <summary>
            Specify the number of concurrent consumers to create. Default is 1.
            </summary>
            <remarks>
            Raising the number of concurrent consumers is recommendable in order
            to scale the consumption of messages coming in from a queue. However,
            note that any ordering guarantees are lost once multiple consumers are
            registered. In general, stick with 1 consumer for low-volume queues.
            <para>Do not raise the number of concurrent consumers for a topic.
            This would lead to concurrent consumption of the same message,
            which is hardly ever desirable.
            </para>
            </remarks>
            <value>The concurrent consumers.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.RecoveryInterval">
            <summary>
            Sets the time interval between connection recovery attempts.  The default is 5 seconds.
            </summary>
            <value>The recovery interval.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.MaxRecoveryTime">
            <summary>
            Sets the max recovery time to try reconnection attempts.  The default is 10 minutes.
            </summary>
            <value>The max recovery time.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Listener.SimpleMessageListenerContainer.SharedConnectionEnabled">
            <summary>
            Always use a shared EMS connection
            </summary>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Converter.IMessageConverter">
            <summary> Strategy interface that specifies a IMessageConverter
            between .NET objects and EMS messages.
            
            </summary>
            <author>Mark Pollack</author>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.IMessageConverter.ToMessage(System.Object,Spring.Messaging.Ems.Common.ISession)">
            <summary> Convert a .NET object to a EMS Message using the supplied session
            to create the message object.
            </summary>
            <param name="objectToConvert">the object to convert
            </param>
            <param name="session">the Session to use for creating a EMS Message
            </param>
            <returns> the EMS Message
            </returns>
            <throws>EMSException if thrown by EMS API methods </throws>
            <throws>MessageConversionException in case of conversion failure </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.IMessageConverter.FromMessage(TIBCO.EMS.Message)">
            <summary> Convert from a EMS Message to a .NET object.</summary>
            <param name="messageToConvert">the message to convert
            </param>
            <returns> the converted .NET object
            </returns>
            <throws>MessageConversionException in case of conversion failure </throws>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Converter.ITypeMapper">
            <summary>
            Provides a layer of indirection when adding the 'type' of the object as a message property.
            </summary>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.ITypeMapper.FromType(System.Type)">
            <summary>
            Convert from a type to a string.
            </summary>
            <param name="typeOfObjectToConvert">The type of object to convert.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.ITypeMapper.ToType(System.String)">
            <summary>
            Convert from a string to a type
            </summary>
            <param name="typeId">The type id.</param>
            <returns></returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.ITypeMapper.TypeIdFieldName">
            <summary>
            Gets the name of the field in the message that has type information..
            </summary>
            <value>The name of the type id field.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Converter.MessageConversionException">
            <summary> Thrown by IMessageConverter implementations when the conversion
            of an object to/from a Message fails.
            </summary>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.MessageConversionException.#ctor(System.String)">
            <summary>
            Creates a new instance of the IMessageConverterException class. with the specified message.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.MessageConversionException.#ctor(System.String,System.Exception)">
            <summary>
            Creates a new instance of the IMessageConverterException class with the specified message
            and root cause.
            </summary>
            <param name="message">
            A message about the exception.
            </param>
            <param name="rootCause">
            The root exception that is being wrapped.
            </param>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter">
             <summary> A simple message converter that can handle TextMessages, BytesMessages,
             MapMessages, and ObjectMessages. Used as default by EmsTemplate, for
             <code>ConvertAndSend</code> and <code>ReceiveAndConvert</code> operations.
            
             <p>Converts a String to a EMS TextMessage, a byte array to a EMS BytesMessage,
             a Map to a EMS MapMessage, and a Serializable object to a EMS ObjectMessage
             (or vice versa).</p>
            
            
             </summary>
             <author>Juergen Hoeller</author>
             <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.ToMessage(System.Object,Spring.Messaging.Ems.Common.ISession)">
            <summary> Convert a .NET object to a EMS Message using the supplied session
            to create the message object.
            </summary>
            <param name="objectToConvert">the object to convert
            </param>
            <param name="session">the Session to use for creating a EMS Message
            </param>
            <returns> the EMS Message
            </returns>
            <throws>EMSException if thrown by EMS API methods </throws>
            <throws>MessageConversionException in case of conversion failure </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.FromMessage(TIBCO.EMS.Message)">
            <summary> Convert from a EMS Message to a .NET object.</summary>
            <param name="messageToConvert">the message to convert
            </param>
            <returns> the converted .NET object
            </returns>
            <throws>MessageConversionException in case of conversion failure </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.CreateMessageForString(System.String,Spring.Messaging.Ems.Common.ISession)">
            <summary> Create a EMS TextMessage for the given String.</summary>
            <param name="text">the String to convert
            </param>
            <param name="session">current EMS session
            </param>
            <returns> the resulting message
            </returns>
            <throws>  EMSException if thrown by EMS methods </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.CreateMessageForByteArray(System.Byte[],Spring.Messaging.Ems.Common.ISession)">
            <summary> Create a EMS BytesMessage for the given byte array.</summary>
            <param name="bytes">the byyte array to convert
            </param>
            <param name="session">current EMS session
            </param>
            <returns> the resulting message
            </returns>
            <throws>  EMSException if thrown by EMS methods </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.CreateMessageForMap(System.Collections.IDictionary,Spring.Messaging.Ems.Common.ISession)">
            <summary> Create a EMS MapMessage for the given Map.</summary>
            <param name="map">the Map to convert
            </param>
            <param name="session">current EMS session
            </param>
            <returns> the resulting message
            </returns>
            <throws>  EMSException if thrown by EMS methods </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.CreateMessageForSerializable(System.Object,Spring.Messaging.Ems.Common.ISession)">
            <summary> Create a EMS ObjectMessage for the given Serializable object.</summary>
            <param name="objectToSend">the Serializable object to convert
            </param>
            <param name="session">current EMS session
            </param>
            <returns> the resulting message
            </returns>
            <throws>  EMSException if thrown by EMS methods </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.ExtractStringFromMessage(TIBCO.EMS.TextMessage)">
            <summary> Extract a String from the given TextMessage.</summary>
            <param name="message">the message to convert
            </param>
            <returns> the resulting String
            </returns>
            <throws>  EMSException if thrown by EMS methods </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.ExtractByteArrayFromMessage(TIBCO.EMS.BytesMessage)">
            <summary> Extract a byte array from the given BytesMessage.</summary>
            <param name="message">the message to convert
            </param>
            <returns> the resulting byte array
            </returns>
            <throws>  EMSException if thrown by EMS methods </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.ExtractMapFromMessage(TIBCO.EMS.MapMessage)">
            <summary> Extract a IDictionary from the given MapMessage.</summary>
            <param name="message">the message to convert
            </param>
            <returns> the resulting Map
            </returns>
            <throws>EMSException if thrown by EMS methods </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.SimpleMessageConverter.ExtractSerializableFromMessage(TIBCO.EMS.ObjectMessage)">
            <summary>
            Extracts the serializable object from the given object message.
            </summary>
            <param name="message">The message to convert.</param>
            <returns>The resulting serializable object.</returns>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Converter.TypeMapper">
            <summary>
            Provides a layer of indirection when adding the 'type' of the object as a message property.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.TypeMapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Spring.Messaging.Ems.Support.Converter.TypeMapper"/> 
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.TypeMapper.FromType(System.Type)">
            <summary>
            Convert from a type to a string.
            </summary>
            <param name="typeOfObjectToConvert">The type of object to convert.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.TypeMapper.ToType(System.String)">
            <summary>
            Convert from a string to a type
            </summary>
            <param name="typeId">The type id.</param>
            <returns></returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.TypeMapper.AfterPropertiesSet">
            <summary>
            Afters the properties set.
            </summary>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.TypeMapper.IdTypeMapping">
            <summary>
            Gets or sets the id type mapping.
            </summary>
            <value>The id type mapping.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.TypeMapper.TypeIdFieldName">
            <summary>
            Gets the name of the field in the message that has type information..
            </summary>
            <value>The name of the type id field.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.TypeMapper.DefaultHashtableClass">
            <summary>
            Sets the default hashtable class.
            </summary>
            <value>The default hashtable class.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.TypeMapper.DefaultNamespace">
            <summary>
            Gets or sets the default namespace.
            </summary>
            <value>The default namespace.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.TypeMapper.DefaultAssemblyName">
            <summary>
            Gets or sets the default name of the assembly.
            </summary>
            <value>The default name of the assembly.</value>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter">
            <summary>
            Convert an object via XML serialization for sending via an ITextMessage
            </summary>
            <author>Mark Pollack</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.ToMessage(System.Object,Spring.Messaging.Ems.Common.ISession)">
            <summary>
            Convert a .NET object to a EMS Message using the supplied session
            to create the message object.
            </summary>
            <param name="objectToConvert">the object to convert</param>
            <param name="session">the Session to use for creating a EMS Message</param>
            <returns>the EMS Message</returns>
            <throws>EMSException if thrown by EMS API methods </throws>
            <throws>MessageConversionException in case of conversion failure </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.GetXmlString(System.Object)">
            <summary>
            Gets the XML string for an object
            </summary>
            <param name="objectToConvert">The object to convert.</param>
            <returns>XML string</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.FromMessage(TIBCO.EMS.Message)">
            <summary>
            Convert from a EMS Message to a .NET object.
            </summary>
            <param name="messageToConvert">the message to convert</param>
            <returns>the converted .NET object</returns>
            <throws>MessageConversionException in case of conversion failure </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.GetTargetType(TIBCO.EMS.TextMessage)">
            <summary>
            Gets the type of the target given the message.
            </summary>
            <param name="message">The message.</param>
            <returns>Type of the target</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.UTF8ByteArrayToString(System.Byte[])">
            <summary>
            Converts a byte array to a UTF8 string.
            </summary>
            <param name="characters">The characters.</param>
            <returns>UTF8 string</returns>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.StringToUTF8ByteArray(System.String)">
            <summary>
            Converts a UTF8 string to a byte array
            </summary>
            <param name="xmlString">The p XML string.</param>
            <returns></returns>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.TypeMapper">
            <summary>
            Sets the type mapper.
            </summary>
            <value>The type mapper.</value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.EncoderShouldEmitUtf8Identifier">
            <summary>
            Gets or sets a value indicating whether encoder should emit UTF8 byte order mark.  Default is false.
            </summary>
            <value>
            	<c>true</c> to specify that a Unicode byte order mark is provided; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="P:Spring.Messaging.Ems.Support.Converter.XmlMessageConverter.ThrowOnInvalidBytes">
            <summary>
            Gets or sets a value indicating whether to throw an exception on invalid bytes.  Default is true. </summary>
            <value>
            	<c>true</c> to specify that an exception be thrown when an invalid encoding is detected; otherwise, <c>false</c>.
            </value>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Destinations.DynamicDestinationResolver">
             <summary> Simple DestinationResolver implementation resolving destination names
             as dynamic destinations.</summary>
            
             <author>Juergen Hoeller</author>
             <author>Mark Pollack (.NET)</author>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.Destinations.IDestinationResolver">
            <summary> Strategy interface for resolving EMS destinations.
            </summary>
            <remarks>
            <para>Used by EmsTemplate for resolving
            destination names from simple Strings to actual
            Destination implementation instances.
            </para>
            
            <para>The default DestinationResolver implementation used by
            EmsTemplate instances is the
            DynamicDestinationResolver class. Consider using the
            JndDestinationResolver for more advanced scenarios.
            </para>
            </remarks>
            <author>Juergen Hoeller</author>
            <author>Mark Pollack (.NET)</author>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Destinations.IDestinationResolver.ResolveDestinationName(Spring.Messaging.Ems.Common.ISession,System.String,System.Boolean)">
            <summary> Resolve the given destination name, either as located resource
            or as dynamic destination.
            </summary>
            <param name="session">the current EMS Session
            </param>
            <param name="destinationName">the name of the destination
            </param>
            <param name="pubSubDomain"><code>true</code> if the domain is pub-sub, <code>false</code> if P2P
            </param>
            <returns> the EMS destination (either a topic or a queue)
            </returns>
            <throws>EMSException if resolution failed </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Destinations.DynamicDestinationResolver.ResolveDestinationName(Spring.Messaging.Ems.Common.ISession,System.String,System.Boolean)">
            <summary> Resolve the given destination name, either as located resource
            or as dynamic destination.
            </summary>
            <param name="session">the current EMS Session
            </param>
            <param name="destinationName">the name of the destination
            </param>
            <param name="pubSubDomain"><code>true</code> if the domain is pub-sub, <code>false</code> if P2P
            </param>
            <returns> the EMS destination (either a topic or a queue)
            </returns>
            <throws>EMSException if resolution failed </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Destinations.DynamicDestinationResolver.ResolveTopic(Spring.Messaging.Ems.Common.ISession,System.String)">
            <summary> Resolve the given destination name to a Topic.</summary>
            <param name="session">the current EMS Session
            </param>
            <param name="topicName">the name of the desired Topic.
            </param>
            <returns> the EMS Topic name
            </returns>
            <throws>EMSException if resolution failed </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.Destinations.DynamicDestinationResolver.ResolveQueue(Spring.Messaging.Ems.Common.ISession,System.String)">
            <summary> Resolve the given destination name to a Queue.</summary>
            <param name="session">the current EMS Session
            </param>
            <param name="queueName">the name of the desired Queue.
            </param>
            <returns> the EMS Queue name
            </returns>
            <throws>EMSException if resolution failed </throws>
        </member>
        <member name="T:Spring.Messaging.Ems.Support.EmsUtils">
            <summary>
            Generic utility methods for working with EMS. Mainly for internal use
            within the framework, but also useful for custom EMS access code.
            </summary>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.CloseConnection(Spring.Messaging.Ems.Common.IConnection)">
            <summary> Close the given EMS Connection and ignore any thrown exception.
            This is useful for typical <code>finally</code> blocks in manual EMS code.
            </summary>
            <param name="con">the EMS Connection to close (may be <code>null</code>)
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.CloseConnection(Spring.Messaging.Ems.Common.IConnection,System.Boolean)">
            <summary> Close the given EMS Connection and ignore any thrown exception.
            This is useful for typical <code>finally</code> blocks in manual EMS code.
            </summary>
            <param name="con">the EMS Connection to close (may be <code>null</code>)
            </param>
            <param name="stop">whether to call <code>stop()</code> before closing
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.CloseSession(Spring.Messaging.Ems.Common.ISession)">
            <summary> Close the given EMS Session and ignore any thrown exception.
            This is useful for typical <code>finally</code> blocks in manual EMS code.
            </summary>
            <param name="session">the EMS Session to close (may be <code>null</code>)
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.CloseMessageProducer(Spring.Messaging.Ems.Common.IMessageProducer)">
            <summary> Close the given EMS MessageProducer and ignore any thrown exception.
            This is useful for typical <code>finally</code> blocks in manual EMS code.
            </summary>
            <param name="producer">the EMS MessageProducer to close (may be <code>null</code>)
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.CloseMessageConsumer(Spring.Messaging.Ems.Common.IMessageConsumer)">
            <summary> Close the given EMS MessageConsumer and ignore any thrown exception.
            This is useful for typical <code>finally</code> blocks in manual EMS code.
            </summary>
            <param name="consumer">the EMS MessageConsumer to close (may be <code>null</code>)
            </param>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.CommitIfNecessary(Spring.Messaging.Ems.Common.ISession)">
            <summary> Commit the Session if not within a distributed transaction.</summary>
            <remarks>Needs investigation - no distributed tx in .NET messaging providers</remarks>
            <param name="session">the EMS Session to commit
            </param>
            <throws>EMSException if committing failed </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.RollbackIfNecessary(Spring.Messaging.Ems.Common.ISession)">
            <summary> Rollback the Session if not within a distributed transaction.</summary>
            <remarks>Needs investigation - no distributed tx in EMS</remarks>
            <param name="session">the EMS Session to rollback
            </param>
            <throws>  EMSException if committing failed </throws>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.CloseQueueBrowser(TIBCO.EMS.QueueBrowser)">
            <summary>
            Closes the given queue browser and ignore any thrown exception.
            This is useful for typical <code>finally</code> blocks in manual EMS code.
            </summary>
            <param name="browser">The queue browser to close (may be <code>null</code>.</param>
        </member>
        <member name="M:Spring.Messaging.Ems.Support.EmsUtils.ConvertAcknowledgementMode(System.Int32)">
            <summary>
            Converts the acknowledgement mode from an integer to an enumeration.  If the integer
            does not match a valid enumeration, the returned enumeration is SessionMode.AutoAcknowledge
            </summary>
            <param name="ackMode">The ack mode.</param>
            <returns>The corresponding SessionMode enumeration</returns>
        </member>
    </members>
</doc>
