#ifndef PROTON_MESSAGE_H
#define PROTON_MESSAGE_H 1

/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 */

#include <proton/import_export.h>
#include <proton/types.h>
#include <proton/codec.h>
#include <proton/error.h>
#include <proton/type_compat.h>

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @file
 *
 * @copybrief message
 *
 * @addtogroup message
 * @{
 */

/**
 * An AMQP Message object.
 *
 * An AMQP Message object is a mutable holder of message content that
 * may be used to generate and encode or decode and access AMQP
 * formatted message data.
 */
typedef struct pn_message_t pn_message_t;

/**
 * Default priority for messages.
 */
#define PN_DEFAULT_PRIORITY (4)

/**
 * Construct a new ::pn_message_t.
 *
 * Every message that is constructed must be freed using
 * ::pn_message_free().
 *
 * @return pointer to a new ::pn_message_t
 */
PN_EXTERN pn_message_t * pn_message(void);

/**
 * Free a previously constructed ::pn_message_t.
 *
 * @param[in] msg pointer to a ::pn_message_t or NULL
 */
PN_EXTERN void           pn_message_free(pn_message_t *msg);

/**
 * Clears the content of a ::pn_message_t.
 *
 * When pn_message_clear returns, the supplied ::pn_message_t will be
 * emptied of all content and effectively returned to the same state
 * as if it was just created.
 *
 * @param[in] msg pointer to the ::pn_message_t to be cleared
 */
PN_EXTERN void           pn_message_clear(pn_message_t *msg);

/**
 * Access the error code of a message.
 *
 * Every operation on a message that can result in an error will set
 * the message's error code in case of error. The pn_message_errno()
 * call will access the error code of the most recent failed
 * operation.
 *
 * @param[in] msg a message
 * @return the message's error code
 */
PN_EXTERN int            pn_message_errno(pn_message_t *msg);

/**
 * Access the error information for a message.
 *
 * Every operation on a message that can result in an error will
 * update the error information held by its error descriptor should
 * that operation fail. The pn_message_error() call will access the
 * error information of the most recent failed operation. The pointer
 * returned by this call is valid until the message is freed.
 *
 * @param[in] msg a message
 * @return the message's error descriptor
 */
PN_EXTERN pn_error_t    *pn_message_error(pn_message_t *msg);

/**
 * Get the inferred flag for a message.
 *
 * The inferred flag for a message indicates how the message content
 * is encoded into AMQP sections. If inferred is true then binary and
 * list values in the body of the message will be encoded as AMQP DATA
 * and AMQP SEQUENCE sections, respectively. If inferred is false,
 * then all values in the body of the message will be encoded as AMQP
 * VALUE sections regardless of their type. Use
 * ::pn_message_set_inferred to set the value.
 *
 * @param[in] msg a message object
 * @return the value of the inferred flag for the message
 */
PN_EXTERN bool           pn_message_is_inferred(pn_message_t *msg);

/**
 * Set the inferred flag for a message.
 *
 * See ::pn_message_is_inferred() for a description of what the
 * inferred flag is.
 *
 * @param[in] msg a message object
 * @param[in] inferred the new value of the inferred flag
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_inferred(pn_message_t *msg, bool inferred);

/**
 * Get the durable flag for a message.
 *
 * The durable flag indicates that any parties taking responsibility
 * for the message must durably store the content.
 *
 * @param[in] msg a message object
 * @return the value of the durable flag
 */
PN_EXTERN bool           pn_message_is_durable            (pn_message_t *msg);

/**
 * Set the durable flag for a message.
 *
 * See ::pn_message_is_durable() for a description of the durable
 * flag.
 *
 * @param[in] msg a message object
 * @param[in] durable the new value of the durable flag
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_durable           (pn_message_t *msg, bool durable);

/**
 * Get the priority for a message.
 *
 * The priority of a message impacts ordering guarantees. Within a
 * given ordered context, higher priority messages may jump ahead of
 * lower priority messages.
 *
 * @param[in] msg a message object
 * @return the message priority
 */
PN_EXTERN uint8_t        pn_message_get_priority          (pn_message_t *msg);

/**
 * Set the priority for a message.
 *
 * See ::pn_message_get_priority() for details on message priority.
 *
 * @param[in] msg a message object
 * @param[in] priority the new priority for the message
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_priority          (pn_message_t *msg, uint8_t priority);

/**
 * Get the ttl for a message.
 *
 * The ttl for a message determines how long a message is considered
 * live. When a message is held for retransmit, the ttl is
 * decremented. Once the ttl reaches zero, the message is considered
 * dead. Once a message is considered dead it may be dropped. Use
 * ::pn_message_set_ttl() to set the ttl for a message.
 *
 * @param[in] msg a message object
 * @return the ttl in milliseconds
 */
PN_EXTERN pn_millis_t    pn_message_get_ttl               (pn_message_t *msg);

/**
 * Set the ttl for a message.
 *
 * See ::pn_message_get_ttl() for a detailed description of message ttl.
 *
 * @param[in] msg a message object
 * @param[in] ttl the new value for the message ttl
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_ttl               (pn_message_t *msg, pn_millis_t ttl);

/**
 * Get the first acquirer flag for a message.
 *
 * When set to true, the first acquirer flag for a message indicates
 * that the recipient of the message is the first recipient to acquire
 * the message, i.e. there have been no failed delivery attempts to
 * other acquirers. Note that this does not mean the message has not
 * been delivered to, but not acquired, by other recipients.
 *
 * @param[in] msg a message object
 * @return the first acquirer flag for the message
 */
PN_EXTERN bool           pn_message_is_first_acquirer     (pn_message_t *msg);

/**
 * Set the first acquirer flag for a message.
 *
 * See ::pn_message_is_first_acquirer() for details on the first
 * acquirer flag.
 *
 * @param[in] msg a message object
 * @param[in] first the new value for the first acquirer flag
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_first_acquirer    (pn_message_t *msg, bool first);

/**
 * Get the delivery count for a message.
 *
 * The delivery count field tracks how many attempts have been made to
 * delivery a message. Use ::pn_message_set_delivery_count() to set
 * the delivery count for a message.
 *
 * @param[in] msg a message object
 * @return the delivery count for the message
 */
PN_EXTERN uint32_t       pn_message_get_delivery_count    (pn_message_t *msg);

/**
 * Set the delivery count for a message.
 *
 * See ::pn_message_get_delivery_count() for details on what the
 * delivery count means.
 *
 * @param[in] msg a message object
 * @param[in] count the new delivery count
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_delivery_count    (pn_message_t *msg, uint32_t count);

/**
 * Get/set the id for a message.
 *
 * The message id provides a globally unique identifier for a message.
 * A message id can be an a string, an unsigned long, a uuid or a
 * binary value. This operation returns a pointer to a ::pn_data_t
 * that can be used to access and/or modify the value of the message
 * id. The pointer is valid until the message is freed. See
 * ::pn_data_t for details on how to get/set the value.
 *
 * @param[in] msg a message object
 * @return pointer to a ::pn_data_t holding the id
 */
PN_EXTERN pn_data_t *    pn_message_id                    (pn_message_t *msg);

/**
 * Get the id for a message.
 *
 * The message id provides a globally unique identifier for a message.
 * A message id can be an a string, an unsigned long, a uuid or a
 * binary value. This operation returns the value of the id using the
 * ::pn_atom_t discriminated union. See ::pn_atom_t for details on how
 * to access the value.
 *
 * @param[in] msg a message object
 * @return the message id
 */
PN_EXTERN pn_atom_t      pn_message_get_id                (pn_message_t *msg);

/**
 * Set the id for a message.
 *
 * See ::pn_message_get_id() for more details on the meaning of the
 * message id. Note that only string, unsigned long, uuid, or binary
 * values are permitted.
 *
 * @param[in] msg a message object
 * @param[in] id the new value of the message id
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_id                (pn_message_t *msg, pn_atom_t id);

/**
 * Get the user id for a message.
 *
 * The pointer referenced by the ::pn_bytes_t struct will be valid
 * until any one of the following operations occur:
 *
 *  - ::pn_message_free()
 *  - ::pn_message_clear()
 *  - ::pn_message_set_user_id()
 *
 * @param[in] msg a message object
 * @return a pn_bytes_t referencing the message's user_id
 */
PN_EXTERN pn_bytes_t     pn_message_get_user_id           (pn_message_t *msg);

/**
 * Set the user id for a message.
 *
 * This operation copies the bytes referenced by the provided
 * ::pn_bytes_t struct.
 *
 * @param[in] msg a message object
 * @param[in] user_id the new user_id for the message
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_user_id           (pn_message_t *msg, pn_bytes_t user_id);

/**
 * Get the address for a message.
 *
 * This operation will return NULL if no address has been set or if
 * the address has been set to NULL. The pointer returned by this
 * operation is valid until any one of the following operations occur:
 *
 *  - ::pn_message_free()
 *  - ::pn_message_clear()
 *  - ::pn_message_set_address()
 *
 * @param[in] msg a message object
 * @return a pointer to the address of the message (or NULL)
 */
PN_EXTERN const char *   pn_message_get_address           (pn_message_t *msg);

/**
 * Set the address for a message.
 *
 * The supplied address pointer must either be NULL or reference a NUL
 * terminated string. When the pointer is NULL, the address of the
 * message is set to NULL. When the pointer is non NULL, the contents
 * are copied into the message.
 *
 * @param[in] msg a message object
 * @param[in] address a pointer to the new address (or NULL)
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_address           (pn_message_t *msg, const char *address);

/**
 * Get the subject for a message.
 *
 * This operation will return NULL if no subject has been set or if
 * the subject has been set to NULL. The pointer returned by this
 * operation is valid until any one of the following operations occur:
 *
 *  - ::pn_message_free()
 *  - ::pn_message_clear()
 *  - ::pn_message_set_subject()
 *
 * @param[in] msg a message object
 * @return a pointer to the subject of the message (or NULL)
 */
PN_EXTERN const char *   pn_message_get_subject           (pn_message_t *msg);

/**
 * Set the subject for a message.
 *
 * The supplied subject pointer must either be NULL or reference a NUL
 * terminated string. When the pointer is NULL, the subject is set to
 * NULL. When the pointer is non NULL, the contents are copied into
 * the message.
 *
 * @param[in] msg a message object
 * @param[in] subject a pointer to the new subject (or NULL)
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_subject           (pn_message_t *msg, const char *subject);

/**
 * Get the reply_to for a message.
 *
 * This operation will return NULL if no reply_to has been set or if
 * the reply_to has been set to NULL. The pointer returned by this
 * operation is valid until any one of the following operations occur:
 *
 *  - ::pn_message_free()
 *  - ::pn_message_clear()
 *  - ::pn_message_set_reply_to()
 *
 * @param[in] msg a message object
 * @return a pointer to the reply_to of the message (or NULL)
 */
PN_EXTERN const char *   pn_message_get_reply_to          (pn_message_t *msg);

/**
 * Set the reply_to for a message.
 *
 * The supplied reply_to pointer must either be NULL or reference a NUL
 * terminated string. When the pointer is NULL, the reply_to is set to
 * NULL. When the pointer is non NULL, the contents are copied into
 * the message.
 *
 * @param[in] msg a message object
 * @param[in] reply_to a pointer to the new reply_to (or NULL)
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_reply_to          (pn_message_t *msg, const char *reply_to);

/**
 * Get/set the correlation id for a message.
 *
 * A correlation id can be an a string, an unsigned long, a uuid or a
 * binary value. This operation returns a pointer to a ::pn_data_t
 * that can be used to access and/or modify the value of the
 * correlation id. The pointer is valid until the message is freed.
 * See ::pn_data_t for details on how to get/set the value.
 *
 * @param[in] msg a message object
 * @return pointer to a ::pn_data_t holding the correlation id
 */
PN_EXTERN pn_data_t *    pn_message_correlation_id        (pn_message_t *msg);

/**
 * Get the correlation id for a message.
 *
 * A correlation id can be an a string, an unsigned long, a uuid or a
 * binary value. This operation returns the value of the id using the
 * ::pn_atom_t discriminated union. See ::pn_atom_t for details on how
 * to access the value.
 *
 * @param[in] msg a message object
 * @return the message id
 */
PN_EXTERN pn_atom_t      pn_message_get_correlation_id    (pn_message_t *msg);

/**
 * Set the correlation id for a message.
 *
 * See ::pn_message_get_correlation_id() for more details on the
 * meaning of the correlation id. Note that only string, unsigned
 * long, uuid, or binary values are permitted.
 *
 * @param[in] msg a message object
 * @param[in] id the new value of the message id
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_correlation_id    (pn_message_t *msg, pn_atom_t id);

/**
 * Get the content_type for a message.
 *
 * This operation will return NULL if no content_type has been set or if
 * the content_type has been set to NULL. The pointer returned by this
 * operation is valid until any one of the following operations occur:
 *
 *  - ::pn_message_free()
 *  - ::pn_message_clear()
 *  - ::pn_message_set_content_type()
 *
 * @param[in] msg a message object
 * @return a pointer to the content_type of the message (or NULL)
 */
PN_EXTERN const char *   pn_message_get_content_type      (pn_message_t *msg);

/**
 * Set the content_type for a message.
 *
 * The supplied content_type pointer must either be NULL or reference a NUL
 * terminated string. When the pointer is NULL, the content_type is set to
 * NULL. When the pointer is non NULL, the contents are copied into
 * the message.
 *
 * @param[in] msg a message object
 * @param[in] type a pointer to the new content_type (or NULL)
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_content_type      (pn_message_t *msg, const char *type);

/**
 * Get the content_encoding for a message.
 *
 * This operation will return NULL if no content_encoding has been set or if
 * the content_encoding has been set to NULL. The pointer returned by this
 * operation is valid until any one of the following operations occur:
 *
 *  - ::pn_message_free()
 *  - ::pn_message_clear()
 *  - ::pn_message_set_content_encoding()
 *
 * @param[in] msg a message object
 * @return a pointer to the content_encoding of the message (or NULL)
 */
PN_EXTERN const char *   pn_message_get_content_encoding  (pn_message_t *msg);

/**
 * Set the content_encoding for a message.
 *
 * The supplied content_encoding pointer must either be NULL or reference a NUL
 * terminated string. When the pointer is NULL, the content_encoding is set to
 * NULL. When the pointer is non NULL, the contents are copied into
 * the message.
 *
 * @param[in] msg a message object
 * @param[in] encoding a pointer to the new content_encoding (or NULL)
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_content_encoding  (pn_message_t *msg, const char *encoding);

/**
 * Get the expiry time for a message.
 *
 * A zero value for the expiry time indicates that the message will
 * never expire. This is the default value.
 *
 * @param[in] msg a message object
 * @return the expiry time for the message
 */
PN_EXTERN pn_timestamp_t pn_message_get_expiry_time       (pn_message_t *msg);

/**
 * Set the expiry time for a message.
 *
 * See ::pn_message_get_expiry_time() for more details.
 *
 * @param[in] msg a message object
 * @param[in] time the new expiry time for the message
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_expiry_time       (pn_message_t *msg, pn_timestamp_t time);

/**
 * Get the creation time for a message.
 *
 * A zero value for the creation time indicates that the creation time
 * has not been set. This is the default value.
 *
 * @param[in] msg a message object
 * @return the creation time for the message
 */
PN_EXTERN pn_timestamp_t pn_message_get_creation_time     (pn_message_t *msg);

/**
 * Set the creation time for a message.
 *
 * See ::pn_message_get_creation_time() for more details.
 *
 * @param[in] msg a message object
 * @param[in] time the new creation time for the message
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_creation_time     (pn_message_t *msg, pn_timestamp_t time);

/**
 * Get the group_id for a message.
 *
 * This operation will return NULL if no group_id has been set or if
 * the group_id has been set to NULL. The pointer returned by this
 * operation is valid until any one of the following operations occur:
 *
 *  - ::pn_message_free()
 *  - ::pn_message_clear()
 *  - ::pn_message_set_group_id()
 *
 * @param[in] msg a message object
 * @return a pointer to the group_id of the message (or NULL)
 */
PN_EXTERN const char *   pn_message_get_group_id          (pn_message_t *msg);

/**
 * Set the group_id for a message.
 *
 * The supplied group_id pointer must either be NULL or reference a NUL
 * terminated string. When the pointer is NULL, the group_id is set to
 * NULL. When the pointer is non NULL, the contents are copied into
 * the message.
 *
 * @param[in] msg a message object
 * @param[in] group_id a pointer to the new group_id (or NULL)
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_group_id          (pn_message_t *msg, const char *group_id);

/**
 * Get the group sequence for a message.
 *
 * The group sequence of a message identifies the relative ordering of
 * messages within a group. The default value for the group sequence
 * of a message is zero.
 *
 * @param[in] msg a message object
 * @return the group sequence for the message
 */
PN_EXTERN pn_sequence_t  pn_message_get_group_sequence    (pn_message_t *msg);

/**
 * Set the group sequence for a message.
 *
 * See ::pn_message_get_group_sequence() for details on what the group
 * sequence means.
 *
 * @param[in] msg a message object
 * @param[in] n the new group sequence for the message
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_group_sequence    (pn_message_t *msg, pn_sequence_t n);

/**
 * Get the reply_to_group_id for a message.
 *
 * This operation will return NULL if no reply_to_group_id has been set or if
 * the reply_to_group_id has been set to NULL. The pointer returned by this
 * operation is valid until any one of the following operations occur:
 *
 *  - ::pn_message_free()
 *  - ::pn_message_clear()
 *  - ::pn_message_set_reply_to_group_id()
 *
 * @param[in] msg a message object
 * @return a pointer to the reply_to_group_id of the message (or NULL)
 */
PN_EXTERN const char *   pn_message_get_reply_to_group_id (pn_message_t *msg);

/**
 * Set the reply_to_group_id for a message.
 *
 * The supplied reply_to_group_id pointer must either be NULL or reference a NUL
 * terminated string. When the pointer is NULL, the reply_to_group_id is set to
 * NULL. When the pointer is non NULL, the contents are copied into
 * the message.
 *
 * @param[in] msg a message object
 * @param[in] reply_to_group_id a pointer to the new reply_to_group_id (or NULL)
 * @return zero on success or an error code on failure
 */
PN_EXTERN int            pn_message_set_reply_to_group_id (pn_message_t *msg, const char *reply_to_group_id);

/**
 * Get/set the delivery instructions for a message.
 *
 * This operation returns a pointer to a ::pn_data_t representing the
 * content of the delivery instructions section of a message. The
 * pointer is valid until the message is freed and may be used to both
 * access and modify the content of the delivery instructions section
 * of a message.
 *
 * The ::pn_data_t must either be empty or consist of a symbol keyed
 * map in order to be considered valid delivery instructions.
 *
 * @param[in] msg a message object
 * @return a pointer to the delivery instructions
 */
PN_EXTERN pn_data_t *pn_message_instructions(pn_message_t *msg);

/**
 * Get/set the annotations for a message.
 *
 * This operation returns a pointer to a ::pn_data_t representing the
 * content of the annotations section of a message. The pointer is
 * valid until the message is freed and may be used to both access and
 * modify the content of the annotations section of a message.
 *
 * The ::pn_data_t must either be empty or consist of a symbol keyed
 * map in order to be considered valid message annotations.
 *
 * @param[in] msg a message object
 * @return a pointer to the message annotations
 */
PN_EXTERN pn_data_t *pn_message_annotations(pn_message_t *msg);

/**
 * Get and set the properties for a message.
 *
 * This operation returns a pointer to a ::pn_data_t representing the
 * content of the properties section of a message. The pointer is
 * valid until the message is freed and may be used to both access and
 * modify the content of the properties section of a message.
 *
 * The ::pn_data_t must either be empty or consist of a string keyed
 * map in order to be considered valid message properties.
 *
 * @param[in] msg a message object
 * @return a pointer to the message properties
 */
PN_EXTERN pn_data_t *pn_message_properties(pn_message_t *msg);

/**
 * Get and set the body of a message.
 *
 * This operation returns a pointer to a ::pn_data_t representing the
 * body of a message. The pointer is valid until the message is freed
 * and may be used to both access and modify the content of the
 * message body.
 *
 * @param[in] msg a message object
 * @return a pointer to the message body
 */
PN_EXTERN pn_data_t *pn_message_body(pn_message_t *msg);

/**
 * Decode/load message content from AMQP formatted binary data.
 *
 * Upon invoking this operation, any existing message content will be
 * cleared and replaced with the content from the provided binary
 * data.
 *
 * @param[in] msg a message object
 * @param[in] bytes the start of the encoded AMQP data
 * @param[in] size the size of the encoded AMQP data
 * @return zero on success or an error code on failure
 */
PN_EXTERN int pn_message_decode(pn_message_t *msg, const char *bytes, size_t size);

/**
 * Encode a message as AMQP formatted binary data.
 *
 * If the buffer space provided is insufficient to store the content
 * held in the message, the operation will fail and return a
 * PN_OVERFLOW error code.
 *
 * @param[in] msg a message object
 * @param[in] bytes the start of empty buffer space
 * @param[inout] size the amount of empty buffer space.
 *   On return size holds the amount of data written
 * @return zero on success or an error code on failure
 */
PN_EXTERN int pn_message_encode(pn_message_t *msg, char *bytes, size_t *size);

/**
 * **Unsettled API**: Encode a message, allocating space if necessary
 *
 * @param[in] msg A message object.
 * @param[inout] buf Used to encode msg.
 *   If buf->start == NULL memory is allocated with malloc().
 *   If buf->size is not large enough, buffer is expanded with realloc().
 *   On return buf holds the address and size of the final buffer.
 *   buf->size may be larger than the length of the encoded message.
 * @return The length of the encoded message or an error code (<0).
 * On error pn_message_error(msg) will provide more information.
 */
PN_EXTERN ssize_t pn_message_encode2(pn_message_t *msg, pn_rwbytes_t *buf);

struct pn_link_t;

/**
 * **Unsettled API**
 *
 * Encode and send a message on a sender link.
 *
 * Performs the following steps:
 * - call pn_message_encode2() to encode the message to a buffer
 * - call pn_link_send() to send the encoded message bytes
 * - call pn_link_advance() to indicate the message is complete
 *
 * Note: you must create a delivery for the message before calling
 * pn_message_send() see pn_delivery()
 *
 * @param[in] msg A message object.
 * @param[in] sender A sending link.
 * @param[inout] buf See pn_message_encode2. If buf == NULL then
 * any memory needed for encoding will be allocated and freed by pn_message_send().
 *
 * @return The length of the encoded message or an error code (<0).
 * On error pn_message_error(msg) will provide more information.
 */
PN_EXTERN ssize_t pn_message_send(pn_message_t *msg, pn_link_t *sender, pn_rwbytes_t *buf);

/**
 * Save message content into a pn_data_t object data. The data object will first be cleared.
 */
PN_EXTERN int pn_message_data(pn_message_t *msg, pn_data_t *data);

/** @}
 */

#ifdef __cplusplus
}
#endif

#endif /* message.h */
