gi-glib-2.0.17: GLib bindings

Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte
License | LGPL-2.1
Maintainer | Iñaki García Etxebarria (garetxe@gmail.com)
Safe Haskell | None
Language | Haskell2010

GI.GLib.Structs.ByteArray

Contents

- Exported types
- Methods
  - free
  - freeToBytes
  - new
  - newTake
  - unref
- Properties
  - data
  - len

Description

Contains the public fields of a GByteArray.

Synopsis

- newtype ByteArray = ByteArray (ManagedPtr ByteArray)
- newZeroByteArray :: MonadIO m => m ByteArray
- noByteArray :: Maybe ByteArray
- byteArrayFree :: (HasCallStack, MonadIO m) => ByteString -> Bool -> m Word8
- byteArrayFreeToBytes :: (HasCallStack, MonadIO m) => ByteString -> m Bytes
- byteArrayNew :: (HasCallStack, MonadIO m) => m ByteString
- byteArrayNewTake :: (HasCallStack, MonadIO m) => ByteString -> m ByteString
- byteArrayUnref :: (HasCallStack, MonadIO m) => ByteString -> m ()
- getByteArrayData :: MonadIO m => ByteArray -> m Word8
- setByteArrayData :: MonadIO m => ByteArray -> Word8 -> m ()
- getByteArrayLen :: MonadIO m => ByteArray -> m Word32
- setByteArrayLen :: MonadIO m => ByteArray -> Word32 -> m ()

# Exported types

newtype ByteArray Source #

Memory-managed wrapper type.

Constructors

ByteArray (ManagedPtr ByteArray) |

Instances

BoxedObject ByteArray Source # |
Instance details Defined in GI.GLib.Structs.ByteArray Methods boxedType :: ByteArray -> IO GType Source #
tag ~ AttrSet => Constructible ByteArray tag Source # |
Instance details Defined in GI.GLib.Structs.ByteArray Methods new :: MonadIO m => (ManagedPtr ByteArray -> ByteArray) -> [AttrOp ByteArray tag] -> m ByteArray Source #

newZeroByteArray :: MonadIO m => m ByteArray Source #

Construct a `ByteArray` struct initialized to zero.

noByteArray :: Maybe ByteArray Source #

A convenience alias for `Nothing` :: `Maybe` `ByteArray`.

# Methods

## free

byteArrayFree Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> ByteString | `array`: a `ByteArray`
-> Bool | `freeSegment`: if `True` the actual byte data is freed as well
-> m Word8 | Returns: the element data if `freeSegment` is `False`, otherwise `Nothing`. The element data should be freed using `free`.

Frees the memory allocated by the `ByteArray`. If `freeSegment` is `True` it frees the actual byte data. If the reference count of `array` is greater than one, the `ByteArray` wrapper is preserved but the size of `array` will be set to zero.

## freeToBytes

byteArrayFreeToBytes Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> ByteString | `array`: a `ByteArray`
-> m Bytes | Returns: a new immutable `Bytes` representing same byte data that was in the array

Transfers the data from the `ByteArray` into a new immutable `Bytes`.

The `ByteArray` is freed unless the reference count of `array` is greater than one, the `ByteArray` wrapper is preserved but the size of `array` will be set to zero.

This is identical to using `bytesNewTake` and `byteArrayFree` together.

Since: 2.32

## new

byteArrayNew Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> m ByteString | Returns: the new `ByteArray`

Creates a new `ByteArray` with a reference count of 1.

## newTake

byteArrayNewTake Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> ByteString | `data`: byte data for the array
-> m ByteString | Returns: a new `ByteArray`

Create byte array containing the data. The data will be owned by the array and will be freed with `free`, i.e. it could be allocated using `strdup`.

Since: 2.32

## unref

byteArrayUnref Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> ByteString | `array`: A `ByteArray`
-> m () |

Atomically decrements the reference count of `array` by one. If the reference count drops to 0, all memory allocated by the array is released. This function is thread-safe and may be called from any thread.

Since: 2.22

# Properties

## data

a pointer to the element data. The data may be moved as elements are added to the `ByteArray`

getByteArrayData :: MonadIO m => ByteArray -> m Word8 Source #

Get the value of the “`data`” field. When overloading is enabled, this is equivalent to

    get byteArray #data

setByteArrayData :: MonadIO m => ByteArray -> Word8 -> m () Source #

Set the value of the “`data`” field. When overloading is enabled, this is equivalent to

    set byteArray [ #data := value ]

## len

the number of elements in the `ByteArray`

getByteArrayLen :: MonadIO m => ByteArray -> m Word32 Source #

Get the value of the “`len`” field. When overloading is enabled, this is equivalent to

    get byteArray #len

setByteArrayLen :: MonadIO m => ByteArray -> Word32 -> m () Source #

Set the value of the “`len`” field. When overloading is enabled, this is equivalent to

    set byteArray [ #len := value ]