#include <Session_99_0.h>
Inheritance diagram for qpid::client::no_keyword::Session_99_0:
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. |
The session class provides methods for a client to establish a session with a server and for both peers to operate the session thereafter.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
transfers | ||
mode | One of:
|
Completion qpid::client::no_keyword::Session_99_0::messageAppend | ( | const string & | reference = string() , |
|
const string & | bytes = string() | |||
) |
This method appends data to a reference.
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.
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.
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.
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.
destination | ||
unit | Specifies the unit of credit balance. |
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.
destination | ||
mode | One of:
|
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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. |
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.