BonoboStreamMem

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

## Synopsis

                        BonoboStreamMem;
                        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);

## Object Hierarchy

      GObject
       +----BonoboObject
             +----BonoboStreamMem

## 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 22. Sample BonoboStreamMem usage

    1
    2
    3
    4
    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

### BonoboStreamMem

    typedef struct _BonoboStreamMem BonoboStreamMem;

### 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 .