prelude-message

Name

prelude-message -- 

Synopsis



typedef     size_t;
typedef     ssize_t;
typedef     uint8_t;
typedef     uint16_t;
typedef     uint32_t;
#define     PRELUDE_MSG_PRIORITY_HIGH
#define     PRELUDE_MSG_PRIORITY_MID
#define     PRELUDE_MSG_PRIORITY_LOW
enum        prelude_msg_status_t;
prelude_msg_status_t prelude_msg_read       (prelude_msg_t **msg,
                                             prelude_io_t *pio);
int         prelude_msg_forward             (prelude_msg_t *msg,
                                             prelude_io_t *dst,
                                             prelude_io_t *src);
int         prelude_msg_get                 (prelude_msg_t *msg,
                                             uint8_t *tag,
                                             uint32_t *len,
                                             void **buf);
void        prelude_msg_recycle             (prelude_msg_t *msg);
void        prelude_msg_mark_end            (prelude_msg_t *msg);
prelude_msg_t* prelude_msg_dynamic_new      (uint8_t tag,
                                             uint8_t priority,
                                             void *data,
                                             prelude_msg_t* (*flush_msg_cb) (void *data));
prelude_msg_t* prelude_msg_new              (size_t msgcount,
                                             size_t msglen,
                                             uint8_t tag,
                                             uint8_t priority);
void        prelude_msg_set                 (prelude_msg_t *msg,
                                             uint8_t tag,
                                             uint32_t len,
                                             const void *data);
int         prelude_msg_write               (prelude_msg_t *msg,
                                             prelude_io_t *dst);
void        prelude_msg_set_tag             (prelude_msg_t *msg,
                                             uint8_t tag);
void        prelude_msg_set_priority        (prelude_msg_t *msg,
                                             uint8_t priority);
uint8_t     prelude_msg_get_tag             (prelude_msg_t *msg);
uint8_t     prelude_msg_get_version         (prelude_msg_t *msg);
uint8_t     prelude_msg_get_priority        (prelude_msg_t *msg);
uint32_t    prelude_msg_get_datalen         (prelude_msg_t *msg);
void        prelude_msg_destroy             (prelude_msg_t *msg);
void        prelude_msg_reset               (prelude_msg_t *msg);

Description

Details

size_t


ssize_t


uint8_t

 typedef unsigned char uint8_t;


uint16_t


uint32_t

 typedef unsigned int uint32_t;


PRELUDE_MSG_PRIORITY_HIGH

#define PRELUDE_MSG_PRIORITY_HIGH 0


PRELUDE_MSG_PRIORITY_MID

#define PRELUDE_MSG_PRIORITY_MID  1


PRELUDE_MSG_PRIORITY_LOW

#define PRELUDE_MSG_PRIORITY_LOW  2


enum prelude_msg_status_t

typedef enum {
        prelude_msg_error      = -1,
        prelude_msg_eof        =  0,
        prelude_msg_unfinished =  1,
        prelude_msg_finished   =  2
} prelude_msg_status_t;


prelude_msg_read ()

prelude_msg_status_t prelude_msg_read       (prelude_msg_t **msg,
                                             prelude_io_t *pio);

Read a message on pio into msg. If msg is NULL, it is allocated. This function will never block.

msg :

Pointer on a prelude_msg_t object address.

pio :

Pointer on a prelude_io_t object.

Returns :

-1 on end of stream or error. 1 if the message is complete, 0 if it need further processing.


prelude_msg_forward ()

int         prelude_msg_forward             (prelude_msg_t *msg,
                                             prelude_io_t *dst,
                                             prelude_io_t *src);

prelude_msg_forward() read the message corresponding to the msg object containing the message header previously gathered using prelude_msg_read_header() from the src object, and transfer it to dst. The header is also transfered.

msg :

Pointer on a prelude_msg_t object containing a message header.

dst :

Pointer on a prelude_io_t object to send message to.

src :

Pointer on a prelude_io_t object to read message from.

Returns :

0 on success, -1 if an error occured.


prelude_msg_get ()

int         prelude_msg_get                 (prelude_msg_t *msg,
                                             uint8_t *tag,
                                             uint32_t *len,
                                             void **buf);

prelude_msg_get() read the next data chunk contained in the message. tag is updated to contain the kind of data the chunk contain. len is updated to contain the len of the data chunk. buf is updated to point on the data chunk.

msg :

Pointer on a prelude_msg_t object representing the message to get data from.

tag :

Pointer on a 8 bits unsigned integer to store the message tag.

len :

Pointer on a 32 bits unsigned integer to store the message len to.

buf :

Address of a pointer to store the buffer starting address.

Returns :

1 on success, 0 if there is no more data chunk to read, or -1 if an error occured.


prelude_msg_recycle ()

void        prelude_msg_recycle             (prelude_msg_t *msg);

Recycle msg so you can write at it again, even thought it was written.

msg :

Pointer on prelude_msg_t object.


prelude_msg_mark_end ()

void        prelude_msg_mark_end            (prelude_msg_t *msg);

Mark end of message in the msg buffer, so you can continue adding different message in the same buffer.

msg :

Pointer on prelude_msg_t object.


prelude_msg_dynamic_new ()

prelude_msg_t* prelude_msg_dynamic_new      (uint8_t tag,
                                             uint8_t priority,
                                             void *data,
                                             prelude_msg_t* (*flush_msg_cb) (void *data));

Allocate a new prelude_msg_t object. prelude_msg_set() can then be used to add chunk of data to the message, and prelude_msg_mark_start() to separate different message in the same buffer.

This function use memory chunk of static size to store the message in. If the size of the data you want to store is bigger than the actual chunk size, flush_msg_cb callback will be called for the current message to be flushed, and the returned message will be used in order to store remaining data.

tag :

A tag identifying the kind of message.

priority :

The priority of this message.

data :

Data to pass to the flush_msg_cb callback function.

flush_msg_cb :

Callback function to call when the buffer need to be flushed.

Returns :

A pointer on a prelude_msg_t object or NULL if an error occured.


prelude_msg_new ()

prelude_msg_t* prelude_msg_new              (size_t msgcount,
                                             size_t msglen,
                                             uint8_t tag,
                                             uint8_t priority);

Allocate a new prelude_msg_t object. prelude_msg_set() can then be used to add chunk of data to the message, and prelude_msg_write() to send it.

msgcount :

Number of chunk of data the created object can accept.

msglen :

Maximum number of bytes the object should handle for all the chunks.

tag :

A tag identifying the kind of message.

priority :

The priority of this message.

Returns :

A pointer on a prelude_msg_t object or NULL if an error occured.


prelude_msg_set ()

void        prelude_msg_set                 (prelude_msg_t *msg,
                                             uint8_t tag,
                                             uint32_t len,
                                             const void *data);

prelude_msg_set() append len bytes of data from the data buffer to the msg object representing a message. The data is tagged with tag.

msg :

Pointer on a prelude_msg_t object to store the data to.

tag :

8 bits unsigned integer describing the kind of data.

len :

len of the data chunk.

data :

Pointer to the starting address of the data.


prelude_msg_write ()

int         prelude_msg_write               (prelude_msg_t *msg,
                                             prelude_io_t *dst);

prelude_msg_write() write the message corresponding to the msg object to dst. The message should have been created using the prelude_msg_new() and prelude_msg_set() functions.

msg :

Pointer on a prelude_msg_t object containing the message.

dst :

Pointer on a prelude_io_t object to send the message to.

Returns :

The number of bytes written, or -1 if an error occured.


prelude_msg_set_tag ()

void        prelude_msg_set_tag             (prelude_msg_t *msg,
                                             uint8_t tag);

Tag msg.

msg :

Pointer on a prelude_msg_t object.

tag :

Tag to associate with msg.


prelude_msg_set_priority ()

void        prelude_msg_set_priority        (prelude_msg_t *msg,
                                             uint8_t priority);

Associate priority with msg.

msg :

Pointer on a prelude_msg_t object.

priority :

Priority to associate with msg.


prelude_msg_get_tag ()

uint8_t     prelude_msg_get_tag             (prelude_msg_t *msg);

prelude_msg_get_tag() return the tag contained in the msg header.

msg :

Pointer on a prelude_msg_t object.

Returns :

A tag.


prelude_msg_get_version ()

uint8_t     prelude_msg_get_version         (prelude_msg_t *msg);

msg :

Returns :


prelude_msg_get_priority ()

uint8_t     prelude_msg_get_priority        (prelude_msg_t *msg);

prelude_msg_get_priority() return the priority contained in the msg header.

msg :

Pointer on a prelude_msg_t object.

Returns :

A priority.


prelude_msg_get_datalen ()

uint32_t    prelude_msg_get_datalen         (prelude_msg_t *msg);

prelude_msg_get_datalen() return the len of the whole message contained in the msg header.

msg :

Pointer on a prelude_msg_t object.

Returns :

Len of the message.


prelude_msg_destroy ()

void        prelude_msg_destroy             (prelude_msg_t *msg);

prelude_msg_destroy() destroy the prelude_msg_t object pointed to by msg. All the ressources for this message are freed.

msg :

Pointer on a prelude_msg_t object.


prelude_msg_reset ()

void        prelude_msg_reset               (prelude_msg_t *msg);

msg :