* Internal handling function for a ssl context * @param ssl ssl context * @param cmd command * @param larg first arg * @param

* Perform a TLS/SSL handshake * @param ssl SSL object * @return int returns diagnostic values */

* Free an allocated SSL structure * @param ssl SSL object to be freed * @return int wether the operation succeeded or not */

* Create a new SSL structure for a connection * @param ctx SSL context object * @return SSL the created SSL oject based on th context

* The number of bytes availabe in the ssl struct that have been read * from the socket, but that have not been returned the SSL_read() * @param

* Read data from an ssl socket * @param ssl ssl structure * @param buf buffer to read into * @param num size of buffer * @retu

* Prepare SSL object to work in client or server mode * @param ssl SSL object to set connect state on */

* Connect the SSL object with a file descriptor * @param ssl SSL object * @param fd file descriptor * @return int wether the ope

* Get the SSL_METHOD for outgoing connections * @return SSL_METHOD * */

* Acknowledge a message * @param deliveryTag the delivery tag * @param flags optional flags * @return bool */

* Initialize the object with an connection * @param connection * @return bool */

* Create a new instance of this object * @return Field* */

* Is the connection closed and full dead? The entire TCP connection has been discarded. * @return bool */

* Are we closing down? * @return bool */

* Extended implementation of the complete method that is called when a message was fully received */

* Get the current receiver for a given consumer tag * @param consumertag the consumer frame * @return DeferredConsumer */

* The default port * @return uint16_t */

* Invalidate the channel * This method is called when the connection is destructed */

* Change the events for which the filedescriptor is monitored * @param events */

* Change the events for which the filedescriptor is monitored * @param events */

* Change the events for which the filedescriptor is monitored * @param events */

* The filedescriptor that is used for this connection * @return int */

* Write encoded payload to the given buffer. */

* Fill an output buffer * @param buffer */

* Flush the throttle * @param max */

* Have we received the header of the frame * @return bool */

* Initialize the object: we are going to receive a message, next frames will be header and data * @param exchange * @param routingkey */

* Is (or was) the connection initialized * @return bool */

* Invalidate the object */

* Max frame size * * If you allocate memory to receive data that you are going to pass to the parse() method, * it might be useful

* Install max-frame size * @param heartbeat suggested heartbeat */

* returns the number of messages * @return uint32_t */

* returns the number of messages * @return uint32_t */

* Does this frame need an end-of-frame seperator? * @return bool */

* Does this frame need an end-of-frame seperator? * @return bool */

* Read a double from the buffer * @return double double read from buffer */

* Read a float from the buffer * @return float float read from buffer. */

* Read the next int8 from the buffer * @param char* buffer buffer to read from * @return int8_t value read */

* Notify the pipe, so that the other thread wakes up * @return bool success/failure (errno is set on failure) */

* Get the number without decimals * @return uint32_t */

* Method that is called when a filedescriptor becomes active * @param fd the filedescriptor that is active * @param ev

* Method that is called immediately after a connection has been constructed. * @param connection The connection object that was just con

* Method that is called when the AMQP connection was blocked. * * This method is called, when the server connection gets blocked for the

* Method that is called when the AMQP protocol was gracefully ended. * This is the counter-part of a call to connection.close(). Note that

* Method that is called when the TCP connection ends up in a connected state * @param connection The TCP connection */

* Method that is called when the timer expired */

* Method that is called when the server sends a heartbeat to the client * @param connection The connection over which the heartbeat was r

* Method to be called when it is detected that the connection was lost * @param state */

* Method that is called when the heartbeat timeout is negotiated between the server and the client. * @param connection The connection t

* Method that is called when the RabbitMQ server and your client application * exchange some properties that describe their identity. *

* Method that is called when the TCP connection ends up in a ready * @param connection The TCP connection */

* Method that is called after a TCP connection has been set up and the initial * TLS handshake is finished too, but right before the AMQP logi

* Method that is called after a TCP connection has been set up, and right before * the SSL handshake is going to be performed to secure the con

* Method that is called when the AMQP connection is no longer blocked. * * This method is called when all resource alarms have cleared an

* Output the object to a stream * @param std::ostream */

* Parse data that was recevied from RabbitMQ * * Every time that data comes in from RabbitMQ, you should call this method to parse

* This frame is part of the shutdown operation * @return bool */

* Get the number of places * @return uint8_t */

* Remove a field from the array */

* Port number * @return uint16_t */

* Publish a message to an exchange. See amqpcpp/channel.h for more details on the flags. * Delays actual publishing depending on the publisher con

* Check if a file descriptor is readable. * @return bool */

* Is the channel ready / has it passed the initial handshake? * @return bool */

* Retrieve the recalls-object that handles bounces * @return The deferred recall object */

* Return whether the message has been previously delivered to (another) client * @return bool */

* Report that the connection is blocked * @param reason */

* Report that a consumer was cancelled by the server (for example because the * queue was removed or the node on which the queue was stored was te

* Report an error to user-space * @param message the error message */

* Report a heartbeat to the connection handler */

* Report to the handler that the channel is opened */

* Report that the connection is unblocked */

* Should the message be put back in the queue? * @return bool */

* Run the thread */

* String representation in SASL PLAIN mode * @return string */

* Should we open a secure connection? * @return bool */

* Send a buffer over the channel * @param frame frame to send * @return bool was frame succesfully sent? */

* Send method for a frame * @param id * @param frame */

* Send data over the connection * @param buffer Buffer to send * @param size Size of the buffer */

* Set the body size * This field is set when the header is received * @param uint64_t */

* Store the max number of channels and max number of frames * @param channels max number of channels * @param size max frame

* Set the heartbeat timeout * @param heartbeat suggested heartbeat timeout by server * @return uint16_t accepted heartbeat

* Mark the protocol as being ok * @param server properties sent by the server * @param client properties to be send back

* Mark the connection as connected */

* Ignore SIGPIPE when there is no MSG_NOSIGNAL. */

* Change the expire time * @param connection * @param timeout */

* Get the size this field will take when * encoded in the AMQP wire-frame format * @return size_t */

* Start the timer (and expose the interval) * @param interval the heartbeat interval proposed by the server * @return uin

* Whether the frame is to be sent synchronously * @return bool */

* Uninstall a consumer callback * @param consumertag The consumer tag */

* Wait until the filedescriptor becomes writable * @return bool */

* Constructor to parse an address string * The address should start with "amqp:// * @param data * @param size * @throws std

* Constructor * @param hostname * @param port * @param order */

* Constructor for a comma separated list * @param buffer * @param size * @throws std::runtime_error */

* Constructor based on incoming frame * @param frame */

* Move constructor * @param array */

* Construct a basic acknowledgement frame * * @param channel Channel identifier * @param deliveryTag server-assigned a

* Construct a basic cancel frame from a received frame * * @param frame received frame to parse */

* Construct a basic cancel ok frame * * @param frame received frame */

* Construct a basic consume frame * * @param channel channel we're working on * @param queueName name of the queue t

* Construct a basic consume frame * * @param consumerTag consumertag specified by client of provided by server */