gi-glib-2.0.23: GLib bindings

CopyrightWill Thompson Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria
Safe HaskellNone
LanguageHaskell2010

GI.GLib.Structs.Bytes

Contents

Description

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

The purpose of a tBytes 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 tBytes without coordinating their activities, resting assured that the byte data will not change or move while they hold a reference.

A tBytes can come from many different origins that may have different procedures for freeing the memory region. Examples are memory from malloc, from memory slices, from a tMappedFile or memory from other allocators.

tBytes work well as keys in tHashTable. Use bytesEqual and bytesHash as parameters to g_hash_table_new() or g_hash_table_new_full(). tBytes can also be used as keys in a tTree by passing the bytesCompare function to g_tree_new().

The data pointed to by this bytes must not be modified. For a mutable array of bytes see tByteArray. Use bytesUnrefToArray to create a mutable array for a tBytes sequence. To create an immutable tBytes from a mutable tByteArray, use the byteArrayFreeToBytes function.

Since: 2.32

Synopsis

Exported types

newtype Bytes Source #

Memory-managed wrapper type.

Constructors

Bytes (ManagedPtr Bytes) 
Instances
Eq Bytes Source # 
Instance details

Defined in GI.GLib.Structs.Bytes

Methods

(==) :: Bytes -> Bytes -> Bool

(/=) :: Bytes -> Bytes -> Bool

BoxedObject Bytes Source # 
Instance details

Defined in GI.GLib.Structs.Bytes

Methods

boxedType :: Bytes -> IO GType

IsGValue Bytes Source #

Convert Bytes to and from GValue with toGValue and fromGValue.

Instance details

Defined in GI.GLib.Structs.Bytes

Methods

toGValue :: Bytes -> IO GValue

fromGValue :: GValue -> IO Bytes

noBytes :: Maybe Bytes Source #

A convenience alias for Nothing :: Maybe Bytes.

Methods

Overloaded methods

compare

bytesCompare Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes1: a pointer to a tBytes

-> Bytes

bytes2: a pointer to a tBytes to compare with bytes1

-> m Int32

Returns: a negative value if bytes1 is less than bytes2, a positive value if bytes1 is greater than bytes2, and zero if bytes1 is equal to bytes2

Compares the two tBytes values.

This function can be used to sort GBytes instances in lexicographical order.

If bytes1 and bytes2 have different length but the shorter one is a prefix of the longer one then the shorter one is considered to be less than the longer one. Otherwise the first byte where both differ is used for comparison. If bytes1 has a smaller value at that position it is considered less, otherwise greater than bytes2.

Since: 2.32

equal

bytesEqual Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes1: a pointer to a tBytes

-> Bytes

bytes2: a pointer to a tBytes to compare with bytes1

-> m Bool

Returns: True if the two keys match.

Compares the two tBytes values being pointed to and returns True if they are equal.

This function can be passed to g_hash_table_new() as the keyEqualFunc parameter, when using non-Nothing tBytes pointers as keys in a tHashTable.

Since: 2.32

getData

bytesGetData Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes: a tBytes

-> m (Maybe ByteString)

Returns: a pointer to the byte data, or Nothing

Get the byte data in the tBytes. This data should not be modified.

This function will always return the same pointer for a given tBytes.

Nothing may be returned if size is 0. This is not guaranteed, as the tBytes may represent an empty string with data non-Nothing and size as 0. Nothing will not be returned if size is non-zero.

Since: 2.32

getSize

bytesGetSize Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes: a tBytes

-> m Word64

Returns: the size

Get the size of the byte data in the tBytes.

This function will always return the same value for a given tBytes.

Since: 2.32

hash

bytesHash Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes: a pointer to a tBytes key

-> m Word32

Returns: a hash value corresponding to the key.

Creates an integer hash code for the byte data in the tBytes.

This function can be passed to g_hash_table_new() as the keyHashFunc parameter, when using non-Nothing tBytes pointers as keys in a tHashTable.

Since: 2.32

new

bytesNew Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Maybe ByteString

data: the data to be used for the bytes

-> m Bytes

Returns: a new tBytes

Creates a new tBytes from data.

data is copied. If size is 0, data may be Nothing.

Since: 2.32

newFromBytes

bytesNewFromBytes Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes: a tBytes

-> Word64

offset: offset which subsection starts at

-> Word64

length: length of subsection

-> m Bytes

Returns: a new tBytes

Creates a tBytes which is a subsection of another tBytes. The offset + length may not be longer than the size of bytes.

A reference to bytes will be held by the newly created tBytes until the byte data is no longer needed.

Since 2.56, if offset is 0 and length matches the size of bytes, then bytes will be returned with the reference count incremented by 1. If bytes is a slice of another tBytes, then the resulting tBytes will reference the same tBytes instead of bytes. This allows consumers to simplify the usage of tBytes when asynchronously writing to streams.

Since: 2.32

newTake

bytesNewTake Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Maybe ByteString

data: the data to be used for the bytes

-> m Bytes

Returns: a new tBytes

Creates a new tBytes from data.

After this call, data belongs to the bytes and may no longer be modified by the caller. free will be called on data when the bytes is no longer in use. Because of this data must have been created by a call to malloc, malloc0 or realloc or by one of the many functions that wrap these calls (such as g_new(), strdup, etc).

For creating tBytes with memory from other allocators, see g_bytes_new_with_free_func().

data may be Nothing if size is 0.

Since: 2.32

ref

bytesRef Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes: a tBytes

-> m Bytes

Returns: the tBytes

Increase the reference count on bytes.

Since: 2.32

unref

bytesUnref Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes: a tBytes

-> m () 

Releases a reference on bytes. This may result in the bytes being freed. If bytes is Nothing, it will return immediately.

Since: 2.32

unrefToArray

bytesUnrefToArray Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes: a tBytes

-> m ByteString

Returns: a new mutable tByteArray containing the same byte data

Unreferences the bytes, and returns a new mutable tByteArray containing the same byte data.

As an optimization, the byte data is transferred to the array without copying if this was the last reference to bytes and bytes was created with bytesNew, bytesNewTake or byteArrayFreeToBytes. In all other cases the data is copied.

Since: 2.32

unrefToData

bytesUnrefToData Source #

Arguments

:: (HasCallStack, MonadIO m) 
=> Bytes

bytes: a tBytes

-> m ByteString

Returns: a pointer to the same byte data, which should be freed with free

Unreferences the bytes, and returns a pointer the same byte data contents.

As an optimization, the byte data is returned without copying if this was the last reference to bytes and bytes was created with bytesNew, bytesNewTake or byteArrayFreeToBytes. In all other cases the data is copied.

Since: 2.32