## BonoboStreamMem

BonoboStreamMem — In-memory implementation of Bonobo::Stream interface.

## Synopsis

    struct      BonoboStreamMem;
    struct      BonoboStreamMemPrivate;
    #define     BONOBO_STREAM_MEM_TYPE
    typedef     BonoboStreamMemClass;
    BonoboStreamMem* bonobo_stream_mem_construct
                                                (BonoboStreamMem *stream_mem,
                                                 const char *buffer,
                                                 size_t size,
                                                 gboolean read_only,
                                                 gboolean resizable);
    BonoboObject* bonobo_stream_mem_create      (const char *buffer,
                                                 size_t size,
                                                 gboolean read_only,
                                                 gboolean resizable);
    const char* bonobo_stream_mem_get_buffer    (BonoboStreamMem *stream_mem);
    size_t      bonobo_stream_mem_get_size      (BonoboStreamMem *stream_mem);

## Description

The BonoboStreamMem is an implementation of the IDL:Bonobo/Stream:1.0 interface. This implementation allows an in-memory buffer to be exposed as a IDL:Bonobo/Stream:1.0 to clients.

Here is a sample way of exposing a C string as an IDL:Bonobo/Stream:1.0:

Example 1. Sample BonoboStreamMem usage

    BonoboStream *make_bonobo_stream_on_string (char *string)
    {
        return bonobo_stream_mem_create (string, strlen (string), TRUE, FALSE);
    }

This example will make the string argument be exposed as a CORBA stream.

## Details

### struct BonoboStreamMem

    struct BonoboStreamMem {

    	BonoboObject parent;

    	char         *buffer;
    	size_t        size;
    	long          pos;
    	gboolean      read_only;
    	gboolean      resizable;
    	char         *content_type;
    	char         *name;

    	BonoboStreamMemPrivate *priv;
    };

### struct BonoboStreamMemPrivate

    struct BonoboStreamMemPrivate;

### BONOBO_STREAM_MEM_TYPE

    #define BONOBO_STREAM_MEM_TYPE        BONOBO_TYPE_STREAM_MEM /* deprecated, you should use BONOBO_TYPE_STREAM_MEM */

### BonoboStreamMemClass

    typedef struct {
    	BonoboObjectClass parent_class;

    	POA_Bonobo_Stream__epv epv;

    	char           *(*get_buffer) (BonoboStreamMem *stream_mem);
    	size_t          (*get_size)   (BonoboStreamMem *stream_mem);
    } BonoboStreamMemClass;

### bonobo_stream_mem_construct ()

    BonoboStreamMem* bonobo_stream_mem_construct
                                                (BonoboStreamMem *stream_mem,
                                                 const char *buffer,
                                                 size_t size,
                                                 gboolean read_only,
                                                 gboolean resizable);

`stream_mem` : |
`buffer` : |
`size` : |
`read_only` : |
`resizable` : |
Returns : |

### bonobo_stream_mem_create ()

    BonoboObject* bonobo_stream_mem_create      (const char *buffer,
                                                 size_t size,
                                                 gboolean read_only,
                                                 gboolean resizable);

Creates a new BonoboStreamMem object.

If `buffer` is non-`NULL`, `size` bytes are copied from it into a new buffer. If `buffer` is `NULL`, a new buffer of size `size` is created and filled with zero bytes.

When data is read out of or (if `read_only` is FALSE) written into the returned BonoboStream object, the read() and write() operations operate on the new buffer. If `resizable` is TRUE, writing or seeking past the end of the buffer will cause the buffer to be expanded (with the new space zero-filled for a seek).

`buffer` : | The data for which a BonoboStreamMem object is to be created.
`size` : | The size in bytes of `buffer`.
`read_only` : | Specifies whether or not the returned BonoboStreamMem object should allow write() operations.
`resizable` : | Whether or not the buffer should be resized as needed.
Returns : | the constructed BonoboStream object

### bonobo_stream_mem_get_buffer ()

    const char* bonobo_stream_mem_get_buffer    (BonoboStreamMem *stream_mem);

Returns the buffer associated with a BonoboStreamMem. If the stream is set to automatically resize itself, this buffer is only guaranteed to stay valid until the next write operation on the stream.

`stream_mem` : | a BonoboStreamMem
Returns : | a buffer containing the data written to the stream (or the data the stream was initialized with if nothing has been written).

### bonobo_stream_mem_get_size ()

    size_t      bonobo_stream_mem_get_size      (BonoboStreamMem *stream_mem);

Returns the size of the data associated with a BonoboStreamMem see bonobo_stream_mem_get_buffer

`stream_mem` : | a BonoboStreamMem
Returns : | the size.

## See Also

BonoboStream | An abstract class to implement IDL:Bonobo/Streams.
IDL:Bonobo/Stream:1.0 | The CORBA interface implemented .