Package ch.bailu.gtk.gio

Class MemoryOutputStream

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.gio.OutputStream
ch.bailu.gtk.gio.MemoryOutputStream
All Implemented Interfaces:
PointerInterface
public class MemoryOutputStream extends OutputStream
#GMemoryOutputStream is a class for using arbitrary
memory chunks as output for GIO streaming output operations.

As of GLib 2.34, #GMemoryOutputStream trivially implements
#GPollableOutputStream: it always polls as ready.

https://docs.gtk.org/gio/class.MemoryOutputStream.html

  • Constructor Details

    • MemoryOutputStream

      public MemoryOutputStream(PointerContainer pointer)

    • MemoryOutputStream

      public MemoryOutputStream(@Nullable Pointer data, long size, MemoryOutputStream.OnReallocFunc realloc_function, MemoryOutputStream.OnDestroyNotify destroy_function)
      Creates a new #GMemoryOutputStream.

      In most cases this is not the function you want. See
      g_memory_output_stream_new_resizable() instead.

      If @data is non-%NULL, the stream will use that for its internal storage.

      If @realloc_fn is non-%NULL, it will be used for resizing the internal
      storage when necessary and the stream will be considered resizable.
      In that case, the stream will start out being (conceptually) empty.
      @size is used only as a hint for how big @data is. Specifically,
      seeking to the end of a newly-created stream will seek to zero, not
      @size. Seeking past the end of the stream and then writing will
      introduce a zero-filled gap.

      If @realloc_fn is %NULL then the stream is fixed-sized. Seeking to
      the end will seek to @size exactly. Writing past the end will give
      an 'out of space' error. Attempting to seek past the end will fail.
      Unlike the resizable case, seeking to an offset within the stream and
      writing will preserve the bytes passed in as @data before that point
      and will return them as part of g_memory_output_stream_steal_data().
      If you intend to seek you should probably therefore ensure that @data
      is properly initialised.

      It is probably only meaningful to provide @data and @size in the case
      that you want a fixed-sized stream. Put another way: if @realloc_fn
      is non-%NULL then it makes most sense to give @data as %NULL and
      @size as 0 (allowing #GMemoryOutputStream to do the initial
      allocation for itself). 
      <!-- language="C" -->
 // a stream that can grow
 stream = g_memory_output_stream_new (NULL, 0, realloc, free);
 
 // another stream that can grow
 stream2 = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
 
 // a fixed-size stream
 data = malloc (200);
 stream3 = g_memory_output_stream_new (data, 200, NULL, free);
      Parameters:
      data - pointer to a chunk of memory to use, or %NULL
      size - the size of @data
      realloc_function - a function with realloc() semantics (like g_realloc()) to be called when @data needs to be grown, or %NULL
      destroy_function - a function to be called on @data when the stream is finalized, or %NULL

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • newResizableMemoryOutputStream

      public static MemoryOutputStream newResizableMemoryOutputStream()
      Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
      for memory allocation.
      Returns:

    • getData

      public Pointer getData()
      Gets any loaded data from the @ostream.

      Note that the returned pointer may become invalid on the next
      write or truncate operation on the stream.
      Returns:
      pointer to the stream's data, or %NULL if the data has been stolen

    • getDataSize

      public long getDataSize()
      Returns the number of bytes from the start up to including the last
      byte written in the stream that has not been truncated away.
      Returns:
      the number of bytes written to the stream

    • getSize

      public long getSize()
      Gets the size of the currently allocated data area (available from
      g_memory_output_stream_get_data()).

      You probably don't want to use this function on resizable streams.
      See g_memory_output_stream_get_data_size() instead. For resizable
      streams the size returned by this function is an implementation
      detail and may be change at any time in response to operations on the
      stream.

      If the stream is fixed-sized (ie: no realloc was passed to
      g_memory_output_stream_new()) then this is the maximum size of the
      stream and further writes will return %G_IO_ERROR_NO_SPACE.

      In any case, if you want the number of bytes currently written to the
      stream, use g_memory_output_stream_get_data_size().
      Returns:
      the number of bytes allocated for the data buffer

    • stealAsBytes

      public Bytes stealAsBytes()
      Returns data from the @ostream as a #GBytes. @ostream must be
      closed before calling this function.
      Returns:
      the stream's data

    • stealData

      public Pointer stealData()
      Gets any loaded data from the @ostream. Ownership of the data
      is transferred to the caller; when no longer needed it must be
      freed using the free function set in @ostream's
      #GMemoryOutputStream:destroy-function property.

      @ostream must be closed before calling this function.
      Returns:
      the stream's data, or %NULL if it has previously been stolen

    • asPollableOutputStream

      public PollableOutputStream asPollableOutputStream()
      Implements interface PollableOutputStream. Call this to get access to interface functions.
      Returns:
      PollableOutputStream

    • asSeekable

      public Seekable asSeekable()
      Implements interface Seekable. Call this to get access to interface functions.
      Returns:
      Seekable

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()