qpid::client::no_keyword::Session_99_0 Class Reference

AMQP 99-0 session API. More...

#include <Session_99_0.h>

Inheritance diagram for qpid::client::no_keyword::Session_99_0:

Inheritance graph
[legend]
Collaboration diagram for qpid::client::no_keyword::Session_99_0:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 Session_99_0 (shared_ptr< SessionCore > core)
Response accessRequest (const string &realm=string(), bool exclusive=false, bool passive=false, bool active=false, bool write=false, bool read=false)
 This method requests an access ticket for an access realm.
Completion exchangeDeclare (uint16_t ticket=0, const string &exchange=string(), const string &type=string(), const string &alternateExchange=string(), bool passive=false, bool durable=false, bool autoDelete=false, const FieldTable &arguments=FieldTable())
 This method creates an exchange if it does not already exist, and if the exchange exists, verifies that it is of the correct and expected class.
Completion exchangeDelete (uint16_t ticket=0, const string &exchange=string(), bool ifUnused=false)
 This method deletes an exchange.
TypedResult< qpid::framing::ExchangeQueryResult > exchangeQuery (uint16_t ticket=0, const string &name=string())
 This method is used to request information on a particular exchange.
Completion queueDeclare (uint16_t ticket=0, const string &queue=string(), const string &alternateExchange=string(), bool passive=false, bool durable=false, bool exclusive=false, bool autoDelete=false, const FieldTable &arguments=FieldTable())
 This method creates or checks a queue.
Completion queueBind (uint16_t ticket=0, const string &queue=string(), const string &exchange=string(), const string &routingKey=string(), const FieldTable &arguments=FieldTable())
 This method binds a queue to an exchange.
Completion queueUnbind (uint16_t ticket=0, const string &queue=string(), const string &exchange=string(), const string &routingKey=string(), const FieldTable &arguments=FieldTable())
 This method unbinds a queue from an exchange.
Completion queuePurge (uint16_t ticket=0, const string &queue=string())
 This method removes all messages from a queue.
Completion queueDelete (uint16_t ticket=0, const string &queue=string(), bool ifUnused=false, bool ifEmpty=false)
 This method deletes a queue.
TypedResult< qpid::framing::QueueQueryResult > queueQuery (const string &queue=string())
 This method requests information about a queue.
Completion basicQos (uint32_t prefetchSize=0, uint16_t prefetchCount=0, bool global=false)
 [DEPRECATED: Basic replaced by message class.
Response basicConsume (uint16_t ticket=0, const string &queue=string(), const string &consumerTag=string(), bool noLocal=false, bool noAck=false, bool exclusive=false, bool nowait=false, const FieldTable &arguments=FieldTable())
 [DEPRECATED: Basic replaced by message class.
Completion basicCancel (const string &consumerTag=string())
 [DEPRECATED: Basic replaced by message class.
Completion basicPublish (uint16_t ticket=0, const string &exchange=string(), const string &routingKey=string(), bool rejectUnroutable=false, bool immediate=false, const MethodContent &content=DefaultContent(std::string()))
 [DEPRECATED: Basic replaced by message class.
Response basicGet (uint16_t ticket=0, const string &queue=string(), bool noAck=false)
 [DEPRECATED: Basic replaced by message class.
Completion basicAck (uint64_t deliveryTag=0, bool multiple=false)
 [DEPRECATED: Basic replaced by message class.
Completion basicReject (uint64_t deliveryTag=0, bool requeue=false)
 [DEPRECATED: Basic replaced by message class.
Completion basicRecover (bool requeue=false)
 [DEPRECATED: Basic replaced by message class.
Response fileQos (uint32_t prefetchSize=0, uint16_t prefetchCount=0, bool global=false)
 This method requests a specific quality of service.
Response fileConsume (uint16_t ticket=0, const string &queue=string(), const string &consumerTag=string(), bool noLocal=false, bool noAck=false, bool exclusive=false, bool nowait=false, const FieldTable &filter=FieldTable())
 This method asks the server to start a "consumer", which is a transient request for messages from a specific queue.
Completion fileCancel (const string &consumerTag=string())
 This method cancels a consumer.
Response fileOpen (const string &identifier=string(), uint64_t contentSize=0)
 This method requests permission to start staging a message.
Response fileOpenOk (uint64_t stagedSize=0)
 This method confirms that the recipient is ready to accept staged data.
Completion fileStage (const MethodContent &content=DefaultContent(std::string()))
 This method stages the message, sending the message content to the recipient from the octet offset specified in the Open-Ok method.
Completion filePublish (uint16_t ticket=0, const string &exchange=string(), const string &routingKey=string(), bool mandatory=false, bool immediate=false, const string &identifier=string())
 This method publishes a staged file message to a specific exchange.
Completion fileAck (uint64_t deliveryTag=0, bool multiple=false)
 This method acknowledges one or more messages delivered via the Deliver method.
Completion fileReject (uint64_t deliveryTag=0, bool requeue=false)
 This method allows a client to reject a message.
Response streamQos (uint32_t prefetchSize=0, uint16_t prefetchCount=0, uint32_t consumeRate=0, bool global=false)
 This method requests a specific quality of service.
Response streamConsume (uint16_t ticket=0, const string &queue=string(), const string &consumerTag=string(), bool noLocal=false, bool exclusive=false, bool nowait=false, const FieldTable &filter=FieldTable())
 This method asks the server to start a "consumer", which is a transient request for messages from a specific queue.
Completion streamCancel (const string &consumerTag=string())
 This method cancels a consumer.
Completion streamPublish (uint16_t ticket=0, const string &exchange=string(), const string &routingKey=string(), bool mandatory=false, bool immediate=false, const MethodContent &content=DefaultContent(std::string()))
 This method publishes a message to a specific exchange.
Completion txSelect ()
 This method sets the session to use standard transactions.
Completion txCommit ()
 This method commits all messages published and acknowledged in the current transaction.
Completion txRollback ()
 This method abandons all messages published and acknowledged in the current transaction.
Completion dtxDemarcationSelect ()
 This method sets the session to use distributed transactions.
TypedResult< qpid::framing::DtxDemarcationStartResult > dtxDemarcationStart (uint16_t ticket=0, const string &xid=string(), bool join=false, bool resume=false)
 This method is called when messages should be produced and consumed on behalf a transaction branch identified by xid.
TypedResult< qpid::framing::DtxDemarcationEndResult > dtxDemarcationEnd (uint16_t ticket=0, const string &xid=string(), bool fail=false, bool suspend=false)
 This method is called when the work done on behalf a transaction branch finishes or needs to be suspended.
TypedResult< qpid::framing::DtxCoordinationCommitResult > dtxCoordinationCommit (uint16_t ticket=0, const string &xid=string(), bool onePhase=false)
 Commit the work done on behalf a transaction branch.
Completion dtxCoordinationForget (uint16_t ticket=0, const string &xid=string())
 This method is called to forget about a heuristically completed transaction branch.
TypedResult< qpid::framing::DtxCoordinationGetTimeoutResult > dtxCoordinationGetTimeout (const string &xid=string())
 This method obtains the current transaction timeout value in seconds.
TypedResult< qpid::framing::DtxCoordinationPrepareResult > dtxCoordinationPrepare (uint16_t ticket=0, const string &xid=string())
 This method prepares for commitment any message produced or consumed on behalf of xid.
TypedResult< qpid::framing::DtxCoordinationRecoverResult > dtxCoordinationRecover (uint16_t ticket=0, bool startscan=false, bool endscan=false)
 This method is called to obtain a list of transaction branches that are in a prepared or heuristically completed state.
TypedResult< qpid::framing::DtxCoordinationRollbackResult > dtxCoordinationRollback (uint16_t ticket=0, const string &xid=string())
 This method rolls back the work associated with xid.
Completion dtxCoordinationSetTimeout (uint16_t ticket=0, const string &xid=string(), uint32_t timeout=0)
 Sets the specified transaction branch timeout value in seconds.
Completion tunnelRequest (const FieldTable &metaData=FieldTable(), const MethodContent &content=DefaultContent(std::string()))
 This method tunnels a block of binary data, which can be an encoded AMQP method or other data.
Completion messageTransfer (uint16_t ticket=0, const string &destination=string(), uint8_t confirmMode=0, uint8_t acquireMode=0, const MethodContent &content=DefaultContent(std::string()))
 This method transfers a message between two peers.
Completion messageReject (const SequenceNumberSet &transfers=SequenceNumberSet(), uint16_t code=0, const string &text=string())
 Indicates that the message transfers are un-processable in some way.
Completion messageAcquire (const SequenceNumberSet &transfers=SequenceNumberSet(), uint8_t mode=0)
 Acquires previously transferred messages for consumption.
Completion messageRelease (const SequenceNumberSet &transfers=SequenceNumberSet())
 Release previously transferred messages that have been acquired for consumption (whether implicitly or explicitly).
Completion messageSubscribe (uint16_t ticket=0, const string &queue=string(), const string &destination=string(), bool noLocal=false, uint8_t confirmMode=0, uint8_t acquireMode=0, bool exclusive=false, const FieldTable &filter=FieldTable())
 This method asks the server to start a "subscription", which is a transient request for messages from a specific queue.
Completion messageCancel (const string &destination=string())
 This method cancels a consumer.
Response messageGet (uint16_t ticket=0, const string &queue=string(), const string &destination=string(), bool noAck=false)
 This method provides a direct access to the messages in a queue using a synchronous dialogue that is designed for specific types of application where synchronous functionality is more important than performance.
Completion messageRecover (bool requeue=false)
 This method asks the broker to redeliver all unacknowledged messages on a specified session.
Completion messageOpen (const string &reference=string())
 This method creates a reference.
Completion messageClose (const string &reference=string())
 This method signals the recipient that no more data will be appended to the reference.
Completion messageAppend (const string &reference=string(), const string &bytes=string())
 This method appends data to a reference.
Completion messageCheckpoint (const string &reference=string(), const string &identifier=string())
 This method provides a means to checkpoint large message transfer.
Response messageResume (const string &reference=string(), const string &identifier=string())
 This method resumes a reference from the last checkpoint.
Completion messageQos (uint32_t prefetchSize=0, uint16_t prefetchCount=0, bool global=false)
 This method requests a specific quality of service.
Completion messageFlowMode (const string &destination=string(), uint8_t mode=0)
 Sets the mode of flow control used for a given destination.
Completion messageFlow (const string &destination=string(), uint8_t unit=0, uint32_t value=0)
 This method controls the flow of message data to a given destination.
Completion messageFlush (const string &destination=string())
 Forces the sender to exhaust his credit supply.
Completion messageStop (const string &destination=string())
 On receipt of this method, a producer of messages MUST set his credit to zero for the given destination.
Completion messageEmpty ()
 Signals that a queue does not contain any messages; usually sent in response to the get method.
Completion messageOffset (uint64_t value=0)
 Returns the data offset into a reference body; usually sent in response to resume method.
TypedResult< qpid::framing::BindingQueryResult > bindingQuery (uint16_t ticket=0, const string &exchange=string(), const string &queue=string(), const string &routingKey=string(), const FieldTable &arguments=FieldTable())
 This method is used to request information on the bindings to a particular exchange.

Detailed Description

AMQP 99-0 session API.

The session class provides methods for a client to establish a session with a server and for both peers to operate the session thereafter.


Member Function Documentation

Response qpid::client::no_keyword::Session_99_0::accessRequest ( const string &  realm = string(),
bool  exclusive = false,
bool  passive = false,
bool  active = false,
bool  write = false,
bool  read = false 
)

This method requests an access ticket for an access realm.

The server responds by granting the access ticket. If the client does not have access rights to the requested realm this causes a connection exception. Access tickets are a per-session resource.

Parameters:
realm Specifies the name of the realm to which the client is requesting access. The realm is a configured server-side object that collects a set of resources (exchanges, queues, etc.). If the session has already requested an access ticket onto this realm, the previous ticket is destroyed and a new ticket is created with the requested access rights, if allowed.
exclusive Request exclusive access to the realm, meaning that this will be the only session that uses the realm's resources.
passive Request message passive access to the specified access realm. Passive access lets a client get information about resources in the realm but not to make any changes to them.
active Request message active access to the specified access realm. Active access lets a client get create and delete resources in the realm.
write Request write access to the specified access realm. Write access lets a client publish messages to all exchanges in the realm.
read Request read access to the specified access realm. Read access lets a client consume messages from queues in the realm.

Completion qpid::client::no_keyword::Session_99_0::basicAck ( uint64_t  deliveryTag = 0,
bool  multiple = false 
)

[DEPRECATED: Basic replaced by message class.

] This method acknowledges one or more messages delivered via the Deliver or Get-Ok methods. The client can ask to confirm a single message or a set of messages up to and including a specific message.

Parameters:
deliveryTag 
multiple If set to 1, the delivery tag is treated as "up to and including", so that the client can acknowledge multiple messages with a single method. If set to zero, the delivery tag refers to a single message. If the multiple field is 1, and the delivery tag is zero, tells the server to acknowledge all outstanding messages.

Completion qpid::client::no_keyword::Session_99_0::basicCancel ( const string &  consumerTag = string()  ) 

[DEPRECATED: Basic replaced by message class.

] This method cancels a consumer. This does not affect already delivered messages, but it does mean the server will not send any more messages for that consumer. The client may receive an arbitrary number of messages in between sending the cancel method and receiving notification of the completion of the cancel command.

Parameters:
consumerTag 

Response qpid::client::no_keyword::Session_99_0::basicConsume ( uint16_t  ticket = 0,
const string &  queue = string(),
const string &  consumerTag = string(),
bool  noLocal = false,
bool  noAck = false,
bool  exclusive = false,
bool  nowait = false,
const FieldTable arguments = FieldTable() 
)

[DEPRECATED: Basic replaced by message class.

] This method asks the server to start a "consumer", which is a transient request for messages from a specific queue. Consumers last as long as the session they were created on, or until the client cancels them.

Parameters:
ticket 
queue Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the session, which is the last declared queue.
consumerTag Specifies the identifier for the consumer. The consumer tag is local to a connection, so two clients can use the same consumer tags. If this field is empty the server will generate a unique tag.
noLocal 
noAck 
exclusive Request exclusive consumer access, meaning only this consumer can access the queue.
nowait If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.
arguments A set of arguments for the consume. The syntax and semantics of these arguments depends on the providers implementation.

Response qpid::client::no_keyword::Session_99_0::basicGet ( uint16_t  ticket = 0,
const string &  queue = string(),
bool  noAck = false 
)

[DEPRECATED: Basic replaced by message class.

] This method provides a direct access to the messages in a queue using a synchronous dialogue that is designed for specific types of application where synchronous functionality is more important than performance.

Parameters:
ticket 
queue Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the session, which is the last declared queue.
noAck 

Completion qpid::client::no_keyword::Session_99_0::basicPublish ( uint16_t  ticket = 0,
const string &  exchange = string(),
const string &  routingKey = string(),
bool  rejectUnroutable = false,
bool  immediate = false,
const MethodContent &  content = DefaultContent(std::string()) 
)

[DEPRECATED: Basic replaced by message class.

] This method publishes a message to a specific exchange. The message will be routed to queues as defined by the exchange configuration and distributed to any active consumers when the transaction, if any, is committed.

Parameters:
ticket 
exchange Specifies the name of the exchange to publish to. The exchange name can be empty, meaning the default exchange. If the exchange name is specified, and that exchange does not exist, the server will raise a channel exception.
routingKey Specifies the routing key for the message. The routing key is used for routing messages depending on the exchange configuration.
rejectUnroutable If the reject-unroutable flag is set, then at the time of publishing the broker determines if the message will be routed to any queues. If it will not be routed to any queue then the broker responds with a basic.reject.
immediate If this flag is set, and the resulting message is delivered to a queue with no consumers, the message will not be queued but will instead be routed to the alternate-exchange for that queue. If no such exchange is defined the message will be silently dropped.
content Message content

Completion qpid::client::no_keyword::Session_99_0::basicQos ( uint32_t  prefetchSize = 0,
uint16_t  prefetchCount = 0,
bool  global = false 
)

[DEPRECATED: Basic replaced by message class.

] This method requests a specific quality of service. The QoS can be specified for the current session or for all sessions on the connection. The particular properties and semantics of a qos method always depend on the content class semantics. Though the qos method could in principle apply to both peers, it is currently meaningful only for the server.

Parameters:
prefetchSize The client can request that messages be sent in advance so that when the client finishes processing a message, the following message is already held locally, rather than needing to be sent within the session. Prefetching gives a performance improvement. This field specifies the prefetch window size in octets. The server will send a message in advance if it is equal to or smaller in size than the available prefetch size (and also falls into other prefetch limits). May be set to zero, meaning "no specific limit", although other prefetch limits may still apply. The prefetch-size is ignored if the no-ack option is set.
prefetchCount Specifies a prefetch window in terms of whole messages. This field may be used in combination with the prefetch-size field; a message will only be sent in advance if both prefetch windows (and those at the session and connection level) allow it. The prefetch-count is ignored if the no-ack option is set.
global By default the QoS settings apply to the current session only. If this field is set, they are applied to the entire connection.

Completion qpid::client::no_keyword::Session_99_0::basicRecover ( bool  requeue = false  ) 

[DEPRECATED: Basic replaced by message class.

] This method asks the broker to redeliver all unacknowledged messages on a specified session. Zero or more messages may be redelivered. This method is only allowed on non-transacted sessions.

Parameters:
requeue If this field is zero, the message will be redelivered to the original recipient. If this bit is 1, the server will attempt to requeue the message, potentially then delivering it to an alternative subscriber.

Completion qpid::client::no_keyword::Session_99_0::basicReject ( uint64_t  deliveryTag = 0,
bool  requeue = false 
)

[DEPRECATED: Basic replaced by message class.

] This method allows a client to reject a message. It can be used to interrupt and cancel large incoming messages, or return untreatable messages to their original queue.

Parameters:
deliveryTag 
requeue If this field is zero, the message will be discarded. If this bit is 1, the server will attempt to requeue the message.

TypedResult<qpid::framing::BindingQueryResult> qpid::client::no_keyword::Session_99_0::bindingQuery ( uint16_t  ticket = 0,
const string &  exchange = string(),
const string &  queue = string(),
const string &  routingKey = string(),
const FieldTable arguments = FieldTable() 
)

This method is used to request information on the bindings to a particular exchange.

Parameters:
ticket 
exchange The name of the exchange for which binding information is being requested. If not specified explicitly the default exchange is implied.
queue If populated then determine whether the given queue is bound to the exchange.
routingKey If populated defines the routing key of the binding of interest, if not populated the request will ignore the routing key on bindings when searching for a match.
arguments If populated defines the arguments of the binding of interest if not populated the request will ignore the arguments on bindings when searching for a match

TypedResult<qpid::framing::DtxCoordinationCommitResult> qpid::client::no_keyword::Session_99_0::dtxCoordinationCommit ( uint16_t  ticket = 0,
const string &  xid = string(),
bool  onePhase = false 
)

Commit the work done on behalf a transaction branch.

This method commits the work associated with xid. Any produced messages are made available and any consumed messages are discarded.

Parameters:
ticket Access-ticket granted by the server for a specific realm.
xid Specifies the xid of the transaction branch to be committed.
onePhase When set then one-phase commit optimization is used.

Completion qpid::client::no_keyword::Session_99_0::dtxCoordinationForget ( uint16_t  ticket = 0,
const string &  xid = string() 
)

This method is called to forget about a heuristically completed transaction branch.

Parameters:
ticket Access-ticket granted by the server for a specific realm.
xid Specifies the xid of the transaction branch to be forgotten.

TypedResult<qpid::framing::DtxCoordinationGetTimeoutResult> qpid::client::no_keyword::Session_99_0::dtxCoordinationGetTimeout ( const string &  xid = string()  ) 

This method obtains the current transaction timeout value in seconds.

If set-timeout was not used prior to invoking this method, the return value is the default timeout; otherwise, the value used in the previous set-timeout call is returned.

Parameters:
xid Specifies the xid of the transaction branch for getting the timeout.

TypedResult<qpid::framing::DtxCoordinationPrepareResult> qpid::client::no_keyword::Session_99_0::dtxCoordinationPrepare ( uint16_t  ticket = 0,
const string &  xid = string() 
)

This method prepares for commitment any message produced or consumed on behalf of xid.

Parameters:
ticket Access-ticket granted by the server for a specific realm.
xid Specifies the xid of the transaction branch that can be prepared.

TypedResult<qpid::framing::DtxCoordinationRecoverResult> qpid::client::no_keyword::Session_99_0::dtxCoordinationRecover ( uint16_t  ticket = 0,
bool  startscan = false,
bool  endscan = false 
)

This method is called to obtain a list of transaction branches that are in a prepared or heuristically completed state.

Parameters:
ticket Access-ticket granted by the server for a specific realm.
startscan Indicates that recovery scan should start.
endscan Indicates that the recovery scan should end after returning the xids.

TypedResult<qpid::framing::DtxCoordinationRollbackResult> qpid::client::no_keyword::Session_99_0::dtxCoordinationRollback ( uint16_t  ticket = 0,
const string &  xid = string() 
)

This method rolls back the work associated with xid.

Any produced messages are discarded and any consumed messages are re-enqueued.

Parameters:
ticket Access-ticket granted by the server for a specific realm.
xid Specifies the xid of the transaction branch that can be rolled back.

Completion qpid::client::no_keyword::Session_99_0::dtxCoordinationSetTimeout ( uint16_t  ticket = 0,
const string &  xid = string(),
uint32_t  timeout = 0 
)

Sets the specified transaction branch timeout value in seconds.

Parameters:
ticket Access-ticket granted by the server for a specific realm.
xid Specifies the xid of the transaction branch for setting the timeout.
timeout The transaction timeout value in seconds.

TypedResult<qpid::framing::DtxDemarcationEndResult> qpid::client::no_keyword::Session_99_0::dtxDemarcationEnd ( uint16_t  ticket = 0,
const string &  xid = string(),
bool  fail = false,
bool  suspend = false 
)

This method is called when the work done on behalf a transaction branch finishes or needs to be suspended.

Parameters:
ticket Access-ticket granted by the server for a specific realm.
xid Specifies the xid of the transaction branch to be ended.
fail If set, indicates that this portion of work has failed; otherwise this portion of work has completed successfully.
suspend Indicates that the transaction branch is temporarily suspended in an incomplete state.

Completion qpid::client::no_keyword::Session_99_0::dtxDemarcationSelect (  ) 

This method sets the session to use distributed transactions.

The client must use this method at least once on a session before using XA demarcation operations.

TypedResult<qpid::framing::DtxDemarcationStartResult> qpid::client::no_keyword::Session_99_0::dtxDemarcationStart ( uint16_t  ticket = 0,
const string &  xid = string(),
bool  join = false,
bool  resume = false 
)

This method is called when messages should be produced and consumed on behalf a transaction branch identified by xid.

Parameters:
ticket Access-ticket granted by the server for a specific realm.
xid Specifies the xid of the transaction branch to be started.
join Indicate whether this is joining an already associated xid. Indicate that the start applies to joining a transaction previously seen.
resume Indicate that the start applies to resuming a suspended transaction branch specified.

Completion qpid::client::no_keyword::Session_99_0::exchangeDeclare ( uint16_t  ticket = 0,
const string &  exchange = string(),
const string &  type = string(),
const string &  alternateExchange = string(),
bool  passive = false,
bool  durable = false,
bool  autoDelete = false,
const FieldTable arguments = FieldTable() 
)

This method creates an exchange if it does not already exist, and if the exchange exists, verifies that it is of the correct and expected class.

Parameters:
ticket When a client defines a new exchange, this belongs to the access realm of the ticket used. All further work done with that exchange must be done with an access ticket for the same realm.
exchange 
type Each exchange belongs to one of a set of exchange types implemented by the server. The exchange types define the functionality of the exchange - i.e. how messages are routed through it. It is not valid or meaningful to attempt to change the type of an existing exchange.
alternateExchange In the event that a message cannot be routed, this is the name of the exchange to which the message will be sent.
passive If set, the server will not create the exchange. The client can use this to check whether an exchange exists without modifying the server state.
durable If set when creating a new exchange, the exchange will be marked as durable. Durable exchanges remain active when a server restarts. Non-durable exchanges (transient exchanges) are purged if/when a server restarts.
autoDelete If set, the exchange is deleted when all queues have finished using it.
arguments A set of arguments for the declaration. The syntax and semantics of these arguments depends on the server implementation. This field is ignored if passive is 1.

Completion qpid::client::no_keyword::Session_99_0::exchangeDelete ( uint16_t  ticket = 0,
const string &  exchange = string(),
bool  ifUnused = false 
)

This method deletes an exchange.

When an exchange is deleted all queue bindings on the exchange are cancelled.

Parameters:
ticket 
exchange 
ifUnused If set, the server will only delete the exchange if it has no queue bindings. If the exchange has queue bindings the server does not delete it but raises a channel exception instead.

TypedResult<qpid::framing::ExchangeQueryResult> qpid::client::no_keyword::Session_99_0::exchangeQuery ( uint16_t  ticket = 0,
const string &  name = string() 
)

This method is used to request information on a particular exchange.

Parameters:
ticket 
name The name of the exchange for which information is requested. If not specified explicitly the default exchange is implied.

Completion qpid::client::no_keyword::Session_99_0::fileAck ( uint64_t  deliveryTag = 0,
bool  multiple = false 
)

This method acknowledges one or more messages delivered via the Deliver method.

The client can ask to confirm a single message or a set of messages up to and including a specific message.

Parameters:
deliveryTag 
multiple If set to 1, the delivery tag is treated as "up to and including", so that the client can acknowledge multiple messages with a single method. If set to zero, the delivery tag refers to a single message. If the multiple field is 1, and the delivery tag is zero, tells the server to acknowledge all outstanding messages.

Completion qpid::client::no_keyword::Session_99_0::fileCancel ( const string &  consumerTag = string()  ) 

This method cancels a consumer.

This does not affect already delivered messages, but it does mean the server will not send any more messages for that consumer.

Parameters:
consumerTag 

Response qpid::client::no_keyword::Session_99_0::fileConsume ( uint16_t  ticket = 0,
const string &  queue = string(),
const string &  consumerTag = string(),
bool  noLocal = false,
bool  noAck = false,
bool  exclusive = false,
bool  nowait = false,
const FieldTable filter = FieldTable() 
)

This method asks the server to start a "consumer", which is a transient request for messages from a specific queue.

Consumers last as long as the session they were created on, or until the client cancels them.

Parameters:
ticket 
queue Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the session, which is the last declared queue.
consumerTag Specifies the identifier for the consumer. The consumer tag is local to a connection, so two clients can use the same consumer tags. If this field is empty the server will generate a unique tag.
noLocal 
noAck 
exclusive Request exclusive consumer access, meaning only this consumer can access the queue.
nowait If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.
filter A set of filters for the consume. The syntax and semantics of these filters depends on the providers implementation.

Response qpid::client::no_keyword::Session_99_0::fileOpen ( const string &  identifier = string(),
uint64_t  contentSize = 0 
)

This method requests permission to start staging a message.

Staging means sending the message into a temporary area at the recipient end and then delivering the message by referring to this temporary area. Staging is how the protocol handles partial file transfers

Parameters:
identifier This is the staging identifier. This is an arbitrary string chosen by the sender. For staging to work correctly the sender must use the same staging identifier when staging the same message a second time after recovery from a failure. A good choice for the staging identifier would be the SHA1 hash of the message properties data (including the original filename, revised time, etc.).
contentSize The size of the content in octets. The recipient may use this information to allocate or check available space in advance, to avoid "disk full" errors during staging of very large messages.

Response qpid::client::no_keyword::Session_99_0::fileOpenOk ( uint64_t  stagedSize = 0  ) 

This method confirms that the recipient is ready to accept staged data.

If the message was already partially-staged at a previous time the recipient will report the number of octets already staged.

Parameters:
stagedSize The amount of previously-staged content in octets. For a new message this will be zero.

Completion qpid::client::no_keyword::Session_99_0::filePublish ( uint16_t  ticket = 0,
const string &  exchange = string(),
const string &  routingKey = string(),
bool  mandatory = false,
bool  immediate = false,
const string &  identifier = string() 
)

This method publishes a staged file message to a specific exchange.

The file message will be routed to queues as defined by the exchange configuration and distributed to any active consumers when the transaction, if any, is committed.

Parameters:
ticket 
exchange Specifies the name of the exchange to publish to. The exchange name can be empty, meaning the default exchange. If the exchange name is specified, and that exchange does not exist, the server will raise a channel exception.
routingKey Specifies the routing key for the message. The routing key is used for routing messages depending on the exchange configuration.
mandatory This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message.
immediate This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set, the server will return an undeliverable message with a Return method. If this flag is zero, the server will queue the message, but with no guarantee that it will ever be consumed.
identifier This is the staging identifier of the message to publish. The message must have been staged. Note that a client can send the Publish method asynchronously without waiting for staging to finish.

Response qpid::client::no_keyword::Session_99_0::fileQos ( uint32_t  prefetchSize = 0,
uint16_t  prefetchCount = 0,
bool  global = false 
)

This method requests a specific quality of service.

The QoS can be specified for the current session or for all sessions on the connection. The particular properties and semantics of a qos method always depend on the content class semantics. Though the qos method could in principle apply to both peers, it is currently meaningful only for the server.

Parameters:
prefetchSize The client can request that messages be sent in advance so that when the client finishes processing a message, the following message is already held locally, rather than needing to be sent within the session. Prefetching gives a performance improvement. This field specifies the prefetch window size in octets. May be set to zero, meaning "no specific limit". Note that other prefetch limits may still apply. The prefetch-size is ignored if the no-ack option is set.
prefetchCount Specifies a prefetch window in terms of whole messages. This is compatible with some file API implementations. This field may be used in combination with the prefetch-size field; a message will only be sent in advance if both prefetch windows (and those at the session and connection level) allow it. The prefetch-count is ignored if the no-ack option is set.
global By default the QoS settings apply to the current session only. If this field is set, they are applied to the entire connection.

Completion qpid::client::no_keyword::Session_99_0::fileReject ( uint64_t  deliveryTag = 0,
bool  requeue = false 
)

This method allows a client to reject a message.

It can be used to return untreatable messages to their original queue. Note that file content is staged before delivery, so the client will not use this method to interrupt delivery of a large message.

Parameters:
deliveryTag 
requeue If this field is zero, the message will be discarded. If this bit is 1, the server will attempt to requeue the message.

Completion qpid::client::no_keyword::Session_99_0::fileStage ( const MethodContent &  content = DefaultContent(std::string())  ) 

This method stages the message, sending the message content to the recipient from the octet offset specified in the Open-Ok method.

Parameters:
content Message content

Completion qpid::client::no_keyword::Session_99_0::messageAcquire ( const SequenceNumberSet &  transfers = SequenceNumberSet(),
uint8_t  mode = 0 
)

Acquires previously transferred messages for consumption.

The acquired ids (if any) are sent via message.acquired.

Parameters:
transfers 
mode One of:
  • any (0): acquire any available messages for consumption
  • all (1): only acquire messages if all are available for consumption

Completion qpid::client::no_keyword::Session_99_0::messageAppend ( const string &  reference = string(),
const string &  bytes = string() 
)

This method appends data to a reference.

Parameters:
reference 
bytes 

Completion qpid::client::no_keyword::Session_99_0::messageCancel ( const string &  destination = string()  ) 

This method cancels a consumer.

This does not affect already delivered messages, but it does mean the server will not send any more messages for that consumer. The client may receive an arbitrary number of messages in between sending the cancel method and receiving the notification of completion of the cancel command.

Parameters:
destination 

Completion qpid::client::no_keyword::Session_99_0::messageCheckpoint ( const string &  reference = string(),
const string &  identifier = string() 
)

This method provides a means to checkpoint large message transfer.

The sender may ask the recipient to checkpoint the contents of a reference using the supplied identifier. The sender may then resume the transfer at a later point. It is at the discretion of the recipient how much data to save with the checkpoint, and the sender MUST honour the offset returned by the resume method.

Parameters:
reference 
identifier This is the checkpoint identifier. This is an arbitrary string chosen by the sender. For checkpointing to work correctly the sender must use the same checkpoint identifier when resuming the message. A good choice for the checkpoint identifier would be the SHA1 hash of the message properties data (including the original filename, revised time, etc.).

Completion qpid::client::no_keyword::Session_99_0::messageClose ( const string &  reference = string()  ) 

This method signals the recipient that no more data will be appended to the reference.

Parameters:
reference 

Completion qpid::client::no_keyword::Session_99_0::messageFlow ( const string &  destination = string(),
uint8_t  unit = 0,
uint32_t  value = 0 
)

This method controls the flow of message data to a given destination.

It is used by the recipient of messages to dynamically match the incoming rate of message flow to its processing or forwarding capacity. Upon receipt of this method, the sender must add "value" number of the specified unit to the available credit balance for the specified destination. A value of (0xFFFFFFFF) indicates an infinite amount of credit. This disables any limit for the given unit until the credit balance is zeroed with message.stop or message.flush.

Parameters:
destination 
unit Specifies the unit of credit balance.
One of:

Parameters:
value A value of (0xFFFFFFFF) indicates an infinite amount of credit.

Completion qpid::client::no_keyword::Session_99_0::messageFlowMode ( const string &  destination = string(),
uint8_t  mode = 0 
)

Sets the mode of flow control used for a given destination.

With credit based flow control, the sender of messages continually maintains its current credit balance with the recipient. The credit balance consists of two values, a message count, and a byte count. Whenever message data is sent, both counts must be decremented. If either value reaches zero, the flow of message data must stop. Additional credit is received via the message.flow method.

The sender MUST NOT send partial framesets. This means that if there is not enough byte credit available to send a complete message, the sender must either wait or use chunked transfer to send the first part of the message data in a complete frameset.

Window based flow control is identical to credit based flow control, however message acknowledgment implicitly grants a single unit of message credit, and the size of the message in byte credits for each acknowledged message.

Parameters:
destination 
mode One of:
  • credit (0): choose credit based flow control
  • window (1): choose window based flow control

Completion qpid::client::no_keyword::Session_99_0::messageFlush ( const string &  destination = string()  ) 

Forces the sender to exhaust his credit supply.

The sender's credit will always be zero when this method completes. The message does not complete until all the message transfers occur.

Parameters:
destination 

Response qpid::client::no_keyword::Session_99_0::messageGet ( uint16_t  ticket = 0,
const string &  queue = string(),
const string &  destination = string(),
bool  noAck = false 
)

This method provides a direct access to the messages in a queue using a synchronous dialogue that is designed for specific types of application where synchronous functionality is more important than performance.

Parameters:
ticket 
queue Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the session, which is the last declared queue.
destination On normal completion of the get request (i.e. a response of ok). A message will be transferred to the supplied destination.
noAck 

Completion qpid::client::no_keyword::Session_99_0::messageOffset ( uint64_t  value = 0  ) 

Returns the data offset into a reference body; usually sent in response to resume method.

Parameters:
value Offset in bytes into message body data.

Completion qpid::client::no_keyword::Session_99_0::messageOpen ( const string &  reference = string()  ) 

This method creates a reference.

A references provides a means to send a message body into a temporary area at the recipient end and then deliver the message by referring to this temporary area. This is how the protocol handles large message transfers.

The scope of a ref is defined to be between calls to open (or resume) and close. Between these points it is valid for a ref to be used from any content data type, and so the receiver must hold onto its contents. Should the session be closed when a ref is still in scope, the receiver may discard its contents (unless it is checkpointed). A ref that is in scope is considered open.

Parameters:
reference 

Completion qpid::client::no_keyword::Session_99_0::messageQos ( uint32_t  prefetchSize = 0,
uint16_t  prefetchCount = 0,
bool  global = false 
)

This method requests a specific quality of service.

The QoS can be specified for the current session or for all sessions on the connection. The particular properties and semantics of a qos method always depend on the content class semantics. Though the qos method could in principle apply to both peers, it is currently meaningful only for the server.

Parameters:
prefetchSize The client can request that messages be sent in advance so that when the client finishes processing a message, the following message is already held locally, rather than needing to be sent within the session. Prefetching gives a performance improvement. This field specifies the prefetch window size in octets. The server will send a message in advance if it is equal to or smaller in size than the available prefetch size (and also falls into other prefetch limits). May be set to zero, meaning "no specific limit", although other prefetch limits may still apply. The prefetch-size is ignored if the no-ack option is set.
prefetchCount Specifies a prefetch window in terms of whole messages. This field may be used in combination with the prefetch-size field; a message will only be sent in advance if both prefetch windows (and those at the session and connection level) allow it. The prefetch-count is ignored if the no-ack option is set.
global By default the QoS settings apply to the current session only. If this field is set, they are applied to the entire connection.

Completion qpid::client::no_keyword::Session_99_0::messageRecover ( bool  requeue = false  ) 

This method asks the broker to redeliver all unacknowledged messages on a specified session.

Zero or more messages may be redelivered. This method is only allowed on non-transacted sessions.

Parameters:
requeue If this field is zero, the message will be redelivered to the original recipient. If this bit is 1, the server will attempt to requeue the message, potentially then delivering it to an alternative subscriber.

Completion qpid::client::no_keyword::Session_99_0::messageReject ( const SequenceNumberSet &  transfers = SequenceNumberSet(),
uint16_t  code = 0,
const string &  text = string() 
)

Indicates that the message transfers are un-processable in some way.

A message may be rejected for a number of reasons. A server may reject a message if it is unroutable. A client may reject a message if it is invalid.

Parameters:
transfers 
code 
text 

Completion qpid::client::no_keyword::Session_99_0::messageRelease ( const SequenceNumberSet &  transfers = SequenceNumberSet()  ) 

Release previously transferred messages that have been acquired for consumption (whether implicitly or explicitly).

Released messages will be available for acquisition by other consumers. The order of released messages may be lost.

Parameters:
transfers 

Response qpid::client::no_keyword::Session_99_0::messageResume ( const string &  reference = string(),
const string &  identifier = string() 
)

This method resumes a reference from the last checkpoint.

A reference is considered to be open (in scope) after a resume even though it will not have been opened via the open method during this session.

Parameters:
reference 
identifier 

Completion qpid::client::no_keyword::Session_99_0::messageStop ( const string &  destination = string()  ) 

On receipt of this method, a producer of messages MUST set his credit to zero for the given destination.

This obeys the generic semantics of command completion, i.e. when confirmation is issued credit MUST be zero and no further messages will be sent until such a time as further credit is received.

Parameters:
destination 

Completion qpid::client::no_keyword::Session_99_0::messageSubscribe ( uint16_t  ticket = 0,
const string &  queue = string(),
const string &  destination = string(),
bool  noLocal = false,
uint8_t  confirmMode = 0,
uint8_t  acquireMode = 0,
bool  exclusive = false,
const FieldTable filter = FieldTable() 
)

This method asks the server to start a "subscription", which is a transient request for messages from a specific queue.

Subscriptions last as long as the session they were created on, or until the client cancels them.

Parameters:
ticket 
queue Specifies the name of the subscribed queue.
destination Specifies the destination for the subscription. The destination is local to a connection, so two clients can use the same destination.
noLocal If the no-local field is set the server will not send messages to the connection that published them.
confirmMode The default confirm-mode for this subscription.
acquireMode The default acquire-mode for this subscription.
exclusive Request exclusive subscription access, meaning only this subscription can access the queue.
filter A set of filters for the subscription. The syntax and semantics of these filters depends on the providers implementation.

Completion qpid::client::no_keyword::Session_99_0::messageTransfer ( uint16_t  ticket = 0,
const string &  destination = string(),
uint8_t  confirmMode = 0,
uint8_t  acquireMode = 0,
const MethodContent &  content = DefaultContent(std::string()) 
)

This method transfers a message between two peers.

When a client uses this method to publish a message to a broker, the destination identifies a specific exchange. The message will then be routed to queues as defined by the exchange configuration and distributed to any active subscriptions when the transaction, if any, is committed.

The client may initiate transfers from the broker by starting a subscription using the subscribe method and passing in a destination, then the broker responds with transfer methods to the specified destination as and when messages arrive in the subscribed queue.

Parameters:
ticket 
destination Specifies the destination to which the message is to be transferred. The destination can be empty, meaning the default exchange or subscription. If the destination is specified, and that exchange or subscription does not exist, the peer must raise a channel exception.
confirmMode 
acquireMode 
content Message content

Completion qpid::client::no_keyword::Session_99_0::queueBind ( uint16_t  ticket = 0,
const string &  queue = string(),
const string &  exchange = string(),
const string &  routingKey = string(),
const FieldTable arguments = FieldTable() 
)

This method binds a queue to an exchange.

Until a queue is bound it will not receive any messages. In a classic messaging model, store-and-forward queues are bound to a direct exchange and subscription queues are bound to a topic exchange.

Parameters:
ticket 
queue Specifies the name of the queue to bind. If the queue name is empty, refers to the current queue for the session, which is the last declared queue.
exchange 
routingKey Specifies the routing key for the binding. The routing key is used for routing messages depending on the exchange configuration. Not all exchanges use a routing key - refer to the specific exchange documentation. If the queue name is empty, the server uses the last queue declared on the session. If the routing key is also empty, the server uses this queue name for the routing key as well. If the queue name is provided but the routing key is empty, the server does the binding with that empty routing key. The meaning of empty routing keys depends on the exchange implementation.
arguments A set of arguments for the binding. The syntax and semantics of these arguments depends on the exchange class.

Completion qpid::client::no_keyword::Session_99_0::queueDeclare ( uint16_t  ticket = 0,
const string &  queue = string(),
const string &  alternateExchange = string(),
bool  passive = false,
bool  durable = false,
bool  exclusive = false,
bool  autoDelete = false,
const FieldTable arguments = FieldTable() 
)

This method creates or checks a queue.

When creating a new queue the client can specify various properties that control the durability of the queue and its contents, and the level of sharing for the queue.

Parameters:
ticket When a client defines a new queue, this belongs to the access realm of the ticket used. All further work done with that queue must be done with an access ticket for the same realm.
queue 
alternateExchange If a message is rejected by a queue, then it is sent to the alternate-exchange. A message may be rejected by a queue for the following reasons: 1. The queue is deleted when it is not empty; 2. Immediate delivery of a message is requested, but there are no consumers connected to the queue.
passive If set, the server will not create the queue. This field allows the client to assert the presence of a queue without modifying the server state.
durable If set when creating a new queue, the queue will be marked as durable. Durable queues remain active when a server restarts. Non-durable queues (transient queues) are purged if/when a server restarts. Note that durable queues do not necessarily hold persistent messages, although it does not make sense to send persistent messages to a transient queue.
exclusive Exclusive queues can only be used from one connection at a time. Once a connection declares an exclusive queue, that queue cannot be used by any other connections until the declaring connection closes.
autoDelete If this field is set and the exclusive field is also set, then the queue MUST be deleted when the connection closes.
If this field is set and the exclusive field is not set the queue is deleted when all the consumers have finished using it. Last consumer can be cancelled either explicitly or because its channel is closed. If there was no consumer ever on the queue, it won't be deleted.

Parameters:
arguments A set of arguments for the declaration. The syntax and semantics of these arguments depends on the server implementation. This field is ignored if passive is 1.

Completion qpid::client::no_keyword::Session_99_0::queueDelete ( uint16_t  ticket = 0,
const string &  queue = string(),
bool  ifUnused = false,
bool  ifEmpty = false 
)

This method deletes a queue.

When a queue is deleted any pending messages are sent to a dead-letter queue if this is defined in the server configuration, and all consumers on the queue are cancelled.

Parameters:
ticket 
queue Specifies the name of the queue to delete. If the queue name is empty, refers to the current queue for the session, which is the last declared queue.
ifUnused If set, the server will only delete the queue if it has no consumers. If the queue has consumers the server does does not delete it but raises a channel exception instead.
ifEmpty If set, the server will only delete the queue if it has no messages.

Completion qpid::client::no_keyword::Session_99_0::queuePurge ( uint16_t  ticket = 0,
const string &  queue = string() 
)

This method removes all messages from a queue.

It does not cancel consumers. Purged messages are deleted without any formal "undo" mechanism.

Parameters:
ticket 
queue Specifies the name of the queue to purge. If the queue name is empty, refers to the current queue for the session, which is the last declared queue.

TypedResult<qpid::framing::QueueQueryResult> qpid::client::no_keyword::Session_99_0::queueQuery ( const string &  queue = string()  ) 

This method requests information about a queue.

Parameters:
queue 

Completion qpid::client::no_keyword::Session_99_0::queueUnbind ( uint16_t  ticket = 0,
const string &  queue = string(),
const string &  exchange = string(),
const string &  routingKey = string(),
const FieldTable arguments = FieldTable() 
)

This method unbinds a queue from an exchange.

Parameters:
ticket 
queue Specifies the name of the queue to unbind.
exchange The name of the exchange to unbind from.
routingKey Specifies the routing key of the binding to unbind.
arguments Specifies the arguments of the binding to unbind.

Completion qpid::client::no_keyword::Session_99_0::streamCancel ( const string &  consumerTag = string()  ) 

This method cancels a consumer.

Since message delivery is asynchronous the client may continue to receive messages for a short while after cancelling a consumer. It may process or discard these as appropriate.

Parameters:
consumerTag 

Response qpid::client::no_keyword::Session_99_0::streamConsume ( uint16_t  ticket = 0,
const string &  queue = string(),
const string &  consumerTag = string(),
bool  noLocal = false,
bool  exclusive = false,
bool  nowait = false,
const FieldTable filter = FieldTable() 
)

This method asks the server to start a "consumer", which is a transient request for messages from a specific queue.

Consumers last as long as the session they were created on, or until the client cancels them.

Parameters:
ticket 
queue Specifies the name of the queue to consume from. If the queue name is null, refers to the current queue for the session, which is the last declared queue.
consumerTag Specifies the identifier for the consumer. The consumer tag is local to a connection, so two clients can use the same consumer tags. If this field is empty the server will generate a unique tag.
noLocal 
exclusive Request exclusive consumer access, meaning only this consumer can access the queue.
nowait If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.
filter A set of filters for the consume. The syntax and semantics of these filters depends on the providers implementation.

Completion qpid::client::no_keyword::Session_99_0::streamPublish ( uint16_t  ticket = 0,
const string &  exchange = string(),
const string &  routingKey = string(),
bool  mandatory = false,
bool  immediate = false,
const MethodContent &  content = DefaultContent(std::string()) 
)

This method publishes a message to a specific exchange.

The message will be routed to queues as defined by the exchange configuration and distributed to any active consumers as appropriate.

Parameters:
ticket 
exchange Specifies the name of the exchange to publish to. The exchange name can be empty, meaning the default exchange. If the exchange name is specified, and that exchange does not exist, the server will raise a channel exception.
routingKey Specifies the routing key for the message. The routing key is used for routing messages depending on the exchange configuration.
mandatory This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message.
immediate This flag tells the server how to react if the message cannot be routed to a queue consumer immediately. If this flag is set, the server will return an undeliverable message with a Return method. If this flag is zero, the server will queue the message, but with no guarantee that it will ever be consumed.
content Message content

Response qpid::client::no_keyword::Session_99_0::streamQos ( uint32_t  prefetchSize = 0,
uint16_t  prefetchCount = 0,
uint32_t  consumeRate = 0,
bool  global = false 
)

This method requests a specific quality of service.

The QoS can be specified for the current session or for all sessions on the connection. The particular properties and semantics of a qos method always depend on the content class semantics. Though the qos method could in principle apply to both peers, it is currently meaningful only for the server.

Parameters:
prefetchSize The client can request that messages be sent in advance so that when the client finishes processing a message, the following message is already held locally, rather than needing to be sent within the session. Prefetching gives a performance improvement. This field specifies the prefetch window size in octets. May be set to zero, meaning "no specific limit". Note that other prefetch limits may still apply.
prefetchCount Specifies a prefetch window in terms of whole messages. This field may be used in combination with the prefetch-size field; a message will only be sent in advance if both prefetch windows (and those at the session and connection level) allow it.
consumeRate Specifies a desired transfer rate in octets per second. This is usually determined by the application that uses the streaming data. A value of zero means "no limit", i.e. as rapidly as possible.
global By default the QoS settings apply to the current session only. If this field is set, they are applied to the entire connection.

Completion qpid::client::no_keyword::Session_99_0::tunnelRequest ( const FieldTable metaData = FieldTable(),
const MethodContent &  content = DefaultContent(std::string()) 
)

This method tunnels a block of binary data, which can be an encoded AMQP method or other data.

The binary data is sent as the content for the Tunnel.Request method.

Parameters:
metaData This field table holds arbitrary meta-data that the sender needs to pass to the recipient.
content Message content

Completion qpid::client::no_keyword::Session_99_0::txCommit (  ) 

This method commits all messages published and acknowledged in the current transaction.

A new transaction starts immediately after a commit.

Completion qpid::client::no_keyword::Session_99_0::txRollback (  ) 

This method abandons all messages published and acknowledged in the current transaction.

A new transaction starts immediately after a rollback.

Completion qpid::client::no_keyword::Session_99_0::txSelect (  ) 

This method sets the session to use standard transactions.

The client must use this method at least once on a session before using the Commit or Rollback methods.


The documentation for this class was generated from the following file:
Generated on Thu Apr 10 11:09:04 2008 for Qpid by  doxygen 1.4.7