Bytes

A simple refcounted data type representing an immutable sequence of zero or more bytes from an unspecified origin.

The purpose of a #GBytes is to keep the memory region that it holds alive for as long as anyone holds a reference to the bytes. When the last reference count is dropped, the memory is released. Multiple unrelated callers can use byte data in the #GBytes without coordinating their activities, resting assured that the byte data will not change or move while they hold a reference.

A #GBytes can come from many different origins that may have different procedures for freeing the memory region. Examples are memory from g_malloc(), from memory slices, from a #GMappedFile or memory from other allocators.

#GBytes work well as keys in #GHashTable. Use g_bytes_equal() and g_bytes_hash() as parameters to g_hash_table_new() or g_hash_table_new_full(). #GBytes can also be used as keys in a #GTree by passing the g_bytes_compare() function to g_tree_new().

The data pointed to by this bytes must not be modified. For a mutable array of bytes see #GByteArray. Use g_bytes_unref_to_array() to create a mutable array for a #GBytes sequence. To create an immutable #GBytes from a mutable #GByteArray, use the g_byte_array_free_to_bytes() function.

class Bytes {

GBytes* getBytesStruct(bool transferOwnership);

void* getStruct();

this(GBytes* gBytes, bool ownedRef);

~this();

this(ubyte[] data);

this(ubyte[] data, GDestroyNotify freeFunc, void* userData);

int compare(Bytes bytes2);

bool equal(Bytes bytes2);

ubyte[] getData();

size_t getSize();

uint hash();

Bytes newFromBytes(size_t offset, size_t length);

alias doref = ref_;

Bytes ref_();

void unref();

ByteArray unrefToArray();

ubyte[] unrefToData();

}

Constructors

this this(GBytes* gBytes, bool ownedRef): Sets our main struct and passes it to the parent class.
this this(ubyte[] data): Creates a new #GBytes from @data.
this this(ubyte[] data, GDestroyNotify freeFunc, void* userData): Creates a #GBytes from @data.

Destructor

~this ~this(): Undocumented in source.

Members

Aliases

doref alias doref = ref_: Undocumented in source.

Functions

compare int compare(Bytes bytes2): Compares the two #GBytes values.
equal bool equal(Bytes bytes2): Compares the two #GBytes values being pointed to and returns %TRUE if they are equal.
getBytesStruct GBytes* getBytesStruct(bool transferOwnership): Get the main Gtk struct
getData ubyte[] getData(): Get the byte data in the #GBytes. This data should not be modified.
getSize size_t getSize(): Get the size of the byte data in the #GBytes.
getStruct void* getStruct(): the main Gtk struct as a void*
hash uint hash(): Creates an integer hash code for the byte data in the #GBytes.
newFromBytes Bytes newFromBytes(size_t offset, size_t length): Creates a #GBytes which is a subsection of another #GBytes. The @offset + @length may not be longer than the size of @bytes.
ref_ Bytes ref_(): Increase the reference count on @bytes.
unref void unref(): Releases a reference on @bytes. This may result in the bytes being freed. If @bytes is %NULL, it will return immediately.
unrefToArray ByteArray unrefToArray(): Unreferences the bytes, and returns a new mutable #GByteArray containing the same byte data.
unrefToData ubyte[] unrefToData(): Unreferences the bytes, and returns a pointer the same byte data contents.

Variables

gBytes GBytes* gBytes;: the main Gtk struct
ownedRef bool ownedRef;: Undocumented in source.