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.

	Note
	This call is not supported by all platforms and may fail if the transport buffer can not be resized.

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