int gre_io_add_mdata(
    gre_io_serialized_data_t **  mbuffer,  
    const char *  key_name,  
    const char *  data_format,  
    const void *  data,  
    int  data_nbytes   
)
            

Add a data change key/value pair to a serialized buffer.   This call can be used to serialize multiple data changes into a single Storyboard IO send operation to improve efficiency.

Once an multi-part data buffer is constructed, it can be sent using the gre_io_send_mdata function.

void gre_io_close( 
    gre_io_t *  handle  
)
            

Close an io connection.   Any pending clients will return with an error on their pending actions.

void gre_io_free_buffer(
    gre_io_serialized_data_t *  buffer  
)  
            

This de-allocates the memory associated with a buffer created through the Storyboard IO API.

void gre_io_grow_buffer(
    gre_io_t*                   handle,
    gre_io_serialized_data_t *  buffer  
)  
            

This function attempts to expand the internal capacity of the Storyboard IO transport to ensure that the payload contained within serialized buffer can be transmitted.

gre_io_t* gre_io_open(
    const char *    io_name,  
    int             flag,  
    ...   
)  
            

Open a Storyboard IO communication channel using a named connection.

int gre_io_receive(
    gre_io_t *                  handle,  
    gre_io_serialized_data_t ** buffer   
)
            

Receive a serialized event from a channel.  By default this call blocks until an event is received or until the channel is destroyed unless the GRE_IO_FLAG_NONBLOCK flag was passed to the gre_io_open()call.

In order to receive events, the handle must have been opened for reading using one of GRE_IO_RDONLY or GRE_IO_XRDONLY.

int gre_io_send(
    gre_io_t *                  handle,  
    gre_io_serialized_data_t *  buffer   
)
            

Send a serialized event buffer to a channel. In order to send events, the handle must have been opened for writing using GRE_IO_WRONLY.

int gre_io_send_mdata(
    gre_io_t *                  handle,  
    gre_io_serialized_data_t *  md_buffer   
)
            

Send a serialized buffer of mdata (data manager key/value pairs) to the handle. The handle must have been opened for writing using GRE_IO_WRONLY.

gre_io_serialized_data_t* gre_io_serialize( 
  gre_io_serialized_data_t *    buffer,  
  const char *                  event_addr,  
  const char *                  event_name,  
  const char *                  event_format,  
  const void *                  event_data,  
  int  event_nbytes   
)  
            

Serialize individual event items (see gre/io_mgr.h) into a single buffer for transmission using Storyboard IO.

gre_io_serialized_data_t* gre_io_size_buffer( 
  gre_io_serialized_data_t *    buffer,  
  int                           nbytes   
) 
            

This function ensures that the specified buffer has enough internal storage capacity for a payload of nbytes size. If the buffer is NULL or the existing capacity is not large enough then a new memory buffer will be assigned to the buffer object.

int gre_io_unserialize( 
  gre_io_serialized_data_t *  buffer,  
  char **  event_addr,  
  char **  event_name,  
  char **  event_format,  
  void **  event_data   
) 
            

Transform a serialized buffer into individual event items (see gre/io_mgr.h).   The pointers returned point back into the content of the serialized buffer so the buffer can't be de-allocated until clients are finished referencing the event items returned from this call.

void gre_io_zero_buffer(
    gre_io_serialized_data_t *  buffer  
)  
            

This clears the internal byte count of the buffer, but does not de-allocate the buffer's memory.

Use this function to reset a buffer in between multiple calls to gre_io_serialize