{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.ByteArray
(
ByteArray(..) ,
newZeroByteArray ,
#if defined(ENABLE_OVERLOADING)
ResolveByteArrayMethod ,
#endif
byteArrayAppend ,
byteArrayFree ,
byteArrayFreeToBytes ,
byteArrayNew ,
byteArrayNewTake ,
byteArrayPrepend ,
byteArrayRef ,
byteArrayRemoveIndex ,
byteArrayRemoveIndexFast ,
byteArrayRemoveRange ,
byteArraySetSize ,
byteArraySizedNew ,
byteArraySort ,
byteArraySortWithData ,
byteArraySteal ,
byteArrayUnref ,
#if defined(ENABLE_OVERLOADING)
byteArray_data ,
#endif
getByteArrayData ,
setByteArrayData ,
#if defined(ENABLE_OVERLOADING)
byteArray_len ,
#endif
getByteArrayLen ,
setByteArrayLen ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.Bytes as GLib.Bytes
#else
import qualified GI.GLib.Callbacks as GLib.Callbacks
import {-# SOURCE #-} qualified GI.GLib.Structs.Bytes as GLib.Bytes
#endif
newtype ByteArray = ByteArray (SP.ManagedPtr ByteArray)
deriving (ByteArray -> ByteArray -> Bool
(ByteArray -> ByteArray -> Bool)
-> (ByteArray -> ByteArray -> Bool) -> Eq ByteArray
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ByteArray -> ByteArray -> Bool
== :: ByteArray -> ByteArray -> Bool
$c/= :: ByteArray -> ByteArray -> Bool
/= :: ByteArray -> ByteArray -> Bool
Eq)
instance SP.ManagedPtrNewtype ByteArray where
toManagedPtr :: ByteArray -> ManagedPtr ByteArray
toManagedPtr (ByteArray ManagedPtr ByteArray
p) = ManagedPtr ByteArray
p
foreign import ccall "g_byte_array_get_type" c_g_byte_array_get_type ::
IO GType
type instance O.ParentTypes ByteArray = '[]
instance O.HasParentTypes ByteArray
instance B.Types.TypedObject ByteArray where
glibType :: IO GType
glibType = IO GType
c_g_byte_array_get_type
instance B.Types.GBoxed ByteArray
instance B.GValue.IsGValue (Maybe ByteArray) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_byte_array_get_type
gvalueSet_ :: Ptr GValue -> Maybe ByteArray -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ByteArray
P.Nothing = Ptr GValue -> Ptr ByteArray -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr ByteArray
forall a. Ptr a
FP.nullPtr :: FP.Ptr ByteArray)
gvalueSet_ Ptr GValue
gv (P.Just ByteArray
obj) = ByteArray -> (Ptr ByteArray -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ByteArray
obj (Ptr GValue -> Ptr ByteArray -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe ByteArray)
gvalueGet_ Ptr GValue
gv = do
Ptr ByteArray
ptr <- Ptr GValue -> IO (Ptr ByteArray)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr ByteArray)
if Ptr ByteArray
ptr Ptr ByteArray -> Ptr ByteArray -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ByteArray
forall a. Ptr a
FP.nullPtr
then ByteArray -> Maybe ByteArray
forall a. a -> Maybe a
P.Just (ByteArray -> Maybe ByteArray)
-> IO ByteArray -> IO (Maybe ByteArray)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ByteArray -> ByteArray)
-> Ptr ByteArray -> IO ByteArray
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr ByteArray -> ByteArray
ByteArray Ptr ByteArray
ptr
else Maybe ByteArray -> IO (Maybe ByteArray)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ByteArray
forall a. Maybe a
P.Nothing
newZeroByteArray :: MonadIO m => m ByteArray
newZeroByteArray :: forall (m :: * -> *). MonadIO m => m ByteArray
newZeroByteArray = IO ByteArray -> m ByteArray
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteArray -> m ByteArray) -> IO ByteArray -> m ByteArray
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr ByteArray)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 IO (Ptr ByteArray)
-> (Ptr ByteArray -> IO ByteArray) -> IO ByteArray
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ByteArray -> ByteArray)
-> Ptr ByteArray -> IO ByteArray
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ByteArray -> ByteArray
ByteArray
instance tag ~ 'AttrSet => Constructible ByteArray tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ByteArray -> ByteArray)
-> [AttrOp ByteArray tag] -> m ByteArray
new ManagedPtr ByteArray -> ByteArray
_ [AttrOp ByteArray tag]
attrs = do
ByteArray
o <- m ByteArray
forall (m :: * -> *). MonadIO m => m ByteArray
newZeroByteArray
ByteArray -> [AttrOp ByteArray 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ByteArray
o [AttrOp ByteArray tag]
[AttrOp ByteArray 'AttrSet]
attrs
ByteArray -> m ByteArray
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteArray
o
getByteArrayData :: MonadIO m => ByteArray -> m Word8
getByteArrayData :: forall (m :: * -> *). MonadIO m => ByteArray -> m Word8
getByteArrayData ByteArray
s = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ ByteArray -> (Ptr ByteArray -> IO Word8) -> IO Word8
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ByteArray
s ((Ptr ByteArray -> IO Word8) -> IO Word8)
-> (Ptr ByteArray -> IO Word8) -> IO Word8
forall a b. (a -> b) -> a -> b
$ \Ptr ByteArray
ptr -> do
Word8
val <- Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek (Ptr ByteArray
ptr Ptr ByteArray -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Word8
Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
val
setByteArrayData :: MonadIO m => ByteArray -> Word8 -> m ()
setByteArrayData :: forall (m :: * -> *). MonadIO m => ByteArray -> Word8 -> m ()
setByteArrayData ByteArray
s Word8
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ByteArray -> (Ptr ByteArray -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ByteArray
s ((Ptr ByteArray -> IO ()) -> IO ())
-> (Ptr ByteArray -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ByteArray
ptr -> do
Ptr Word8 -> Word8 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ByteArray
ptr Ptr ByteArray -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Word8
val :: Word8)
#if defined(ENABLE_OVERLOADING)
data ByteArrayDataFieldInfo
instance AttrInfo ByteArrayDataFieldInfo where
type AttrBaseTypeConstraint ByteArrayDataFieldInfo = (~) ByteArray
type AttrAllowedOps ByteArrayDataFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ByteArrayDataFieldInfo = (~) Word8
type AttrTransferTypeConstraint ByteArrayDataFieldInfo = (~)Word8
type AttrTransferType ByteArrayDataFieldInfo = Word8
type AttrGetType ByteArrayDataFieldInfo = Word8
type AttrLabel ByteArrayDataFieldInfo = "data"
type AttrOrigin ByteArrayDataFieldInfo = ByteArray
attrGet = getByteArrayData
attrSet = setByteArrayData
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.ByteArray.data"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-ByteArray.html#g:attr:data"
})
byteArray_data :: AttrLabelProxy "data"
byteArray_data = AttrLabelProxy
#endif
getByteArrayLen :: MonadIO m => ByteArray -> m Word32
getByteArrayLen :: forall (m :: * -> *). MonadIO m => ByteArray -> m Word32
getByteArrayLen ByteArray
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ ByteArray -> (Ptr ByteArray -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ByteArray
s ((Ptr ByteArray -> IO Word32) -> IO Word32)
-> (Ptr ByteArray -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr ByteArray
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ByteArray
ptr Ptr ByteArray -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setByteArrayLen :: MonadIO m => ByteArray -> Word32 -> m ()
setByteArrayLen :: forall (m :: * -> *). MonadIO m => ByteArray -> Word32 -> m ()
setByteArrayLen ByteArray
s Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ByteArray -> (Ptr ByteArray -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ByteArray
s ((Ptr ByteArray -> IO ()) -> IO ())
-> (Ptr ByteArray -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ByteArray
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ByteArray
ptr Ptr ByteArray -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data ByteArrayLenFieldInfo
instance AttrInfo ByteArrayLenFieldInfo where
type AttrBaseTypeConstraint ByteArrayLenFieldInfo = (~) ByteArray
type AttrAllowedOps ByteArrayLenFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ByteArrayLenFieldInfo = (~) Word32
type AttrTransferTypeConstraint ByteArrayLenFieldInfo = (~)Word32
type AttrTransferType ByteArrayLenFieldInfo = Word32
type AttrGetType ByteArrayLenFieldInfo = Word32
type AttrLabel ByteArrayLenFieldInfo = "len"
type AttrOrigin ByteArrayLenFieldInfo = ByteArray
attrGet = getByteArrayLen
attrSet = setByteArrayLen
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.ByteArray.len"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-ByteArray.html#g:attr:len"
})
byteArray_len :: AttrLabelProxy "len"
byteArray_len = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ByteArray
type instance O.AttributeList ByteArray = ByteArrayAttributeList
type ByteArrayAttributeList = ('[ '("data", ByteArrayDataFieldInfo), '("len", ByteArrayLenFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_byte_array_append" g_byte_array_append ::
Ptr GByteArray ->
Word8 ->
Word32 ->
IO (Ptr GByteArray)
byteArrayAppend ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> Word8
-> Word32
-> m ByteString
byteArrayAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> Word8 -> Word32 -> m ByteString
byteArrayAppend ByteString
array Word8
data_ Word32
len = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr GByteArray
result <- Ptr GByteArray -> Word8 -> Word32 -> IO (Ptr GByteArray)
g_byte_array_append Ptr GByteArray
array' Word8
data_ Word32
len
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayAppend" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_free" g_byte_array_free ::
Ptr GByteArray ->
CInt ->
IO Word8
byteArrayFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> Bool
-> m Word8
byteArrayFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> Bool -> m Word8
byteArrayFree ByteString
array Bool
freeSegment = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
let freeSegment' :: CInt
freeSegment' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
freeSegment
Word8
result <- Ptr GByteArray -> CInt -> IO Word8
g_byte_array_free Ptr GByteArray
array' CInt
freeSegment'
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_free_to_bytes" g_byte_array_free_to_bytes ::
Ptr GByteArray ->
IO (Ptr GLib.Bytes.Bytes)
byteArrayFreeToBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m GLib.Bytes.Bytes
byteArrayFreeToBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m Bytes
byteArrayFreeToBytes ByteString
array = IO Bytes -> m Bytes
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bytes -> m Bytes) -> IO Bytes -> m Bytes
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr Bytes
result <- Ptr GByteArray -> IO (Ptr Bytes)
g_byte_array_free_to_bytes Ptr GByteArray
array'
Text -> Ptr Bytes -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayFreeToBytes" Ptr Bytes
result
Bytes
result' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
Bytes -> IO Bytes
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_new" g_byte_array_new ::
IO (Ptr GByteArray)
byteArrayNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ByteString
byteArrayNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ByteString
byteArrayNew = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
result <- IO (Ptr GByteArray)
g_byte_array_new
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayNew" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
result
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_new_take" g_byte_array_new_take ::
Ptr Word8 ->
FCT.CSize ->
IO (Ptr GByteArray)
byteArrayNewTake ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m ByteString
byteArrayNewTake :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m ByteString
byteArrayNewTake ByteString
data_ = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
let len :: CSize
len = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
data_
Ptr Word8
data_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
data_
Ptr GByteArray
result <- Ptr Word8 -> CSize -> IO (Ptr GByteArray)
g_byte_array_new_take Ptr Word8
data_' CSize
len
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayNewTake" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
result
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_prepend" g_byte_array_prepend ::
Ptr GByteArray ->
Word8 ->
Word32 ->
IO (Ptr GByteArray)
byteArrayPrepend ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> Word8
-> Word32
-> m ByteString
byteArrayPrepend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> Word8 -> Word32 -> m ByteString
byteArrayPrepend ByteString
array Word8
data_ Word32
len = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr GByteArray
result <- Ptr GByteArray -> Word8 -> Word32 -> IO (Ptr GByteArray)
g_byte_array_prepend Ptr GByteArray
array' Word8
data_ Word32
len
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayPrepend" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_ref" g_byte_array_ref ::
Ptr GByteArray ->
IO (Ptr GByteArray)
byteArrayRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m ByteString
byteArrayRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m ByteString
byteArrayRef ByteString
array = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr GByteArray
result <- Ptr GByteArray -> IO (Ptr GByteArray)
g_byte_array_ref Ptr GByteArray
array'
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayRef" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_remove_index" g_byte_array_remove_index ::
Ptr GByteArray ->
Word32 ->
IO (Ptr GByteArray)
byteArrayRemoveIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> Word32
-> m ByteString
byteArrayRemoveIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> Word32 -> m ByteString
byteArrayRemoveIndex ByteString
array Word32
index_ = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr GByteArray
result <- Ptr GByteArray -> Word32 -> IO (Ptr GByteArray)
g_byte_array_remove_index Ptr GByteArray
array' Word32
index_
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayRemoveIndex" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_remove_index_fast" g_byte_array_remove_index_fast ::
Ptr GByteArray ->
Word32 ->
IO (Ptr GByteArray)
byteArrayRemoveIndexFast ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> Word32
-> m ByteString
byteArrayRemoveIndexFast :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> Word32 -> m ByteString
byteArrayRemoveIndexFast ByteString
array Word32
index_ = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr GByteArray
result <- Ptr GByteArray -> Word32 -> IO (Ptr GByteArray)
g_byte_array_remove_index_fast Ptr GByteArray
array' Word32
index_
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayRemoveIndexFast" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_remove_range" g_byte_array_remove_range ::
Ptr GByteArray ->
Word32 ->
Word32 ->
IO (Ptr GByteArray)
byteArrayRemoveRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> Word32
-> Word32
-> m ByteString
byteArrayRemoveRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> Word32 -> Word32 -> m ByteString
byteArrayRemoveRange ByteString
array Word32
index_ Word32
length_ = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr GByteArray
result <- Ptr GByteArray -> Word32 -> Word32 -> IO (Ptr GByteArray)
g_byte_array_remove_range Ptr GByteArray
array' Word32
index_ Word32
length_
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArrayRemoveRange" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_set_size" g_byte_array_set_size ::
Ptr GByteArray ->
Word32 ->
IO (Ptr GByteArray)
byteArraySetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> Word32
-> m ByteString
byteArraySetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> Word32 -> m ByteString
byteArraySetSize ByteString
array Word32
length_ = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr GByteArray
result <- Ptr GByteArray -> Word32 -> IO (Ptr GByteArray)
g_byte_array_set_size Ptr GByteArray
array' Word32
length_
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArraySetSize" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_sized_new" g_byte_array_sized_new ::
Word32 ->
IO (Ptr GByteArray)
byteArraySizedNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m ByteString
byteArraySizedNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> m ByteString
byteArraySizedNew Word32
reservedSize = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
result <- Word32 -> IO (Ptr GByteArray)
g_byte_array_sized_new Word32
reservedSize
Text -> Ptr GByteArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"byteArraySizedNew" Ptr GByteArray
result
ByteString
result' <- Ptr GByteArray -> IO ByteString
unpackGByteArray Ptr GByteArray
result
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
result
ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_sort" g_byte_array_sort ::
Ptr GByteArray ->
FunPtr GLib.Callbacks.C_CompareFunc ->
IO ()
byteArraySort ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> GLib.Callbacks.CompareFunc
-> m ()
byteArraySort :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> CompareFunc -> m ()
byteArraySort ByteString
array CompareFunc
compareFunc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
FunPtr C_CompareFunc
compareFunc' <- C_CompareFunc -> IO (FunPtr C_CompareFunc)
GLib.Callbacks.mk_CompareFunc (Maybe (Ptr (FunPtr C_CompareFunc))
-> C_CompareFunc -> C_CompareFunc
GLib.Callbacks.wrap_CompareFunc Maybe (Ptr (FunPtr C_CompareFunc))
forall a. Maybe a
Nothing (CompareFunc -> C_CompareFunc
GLib.Callbacks.drop_closures_CompareFunc CompareFunc
compareFunc))
Ptr GByteArray -> FunPtr C_CompareFunc -> IO ()
g_byte_array_sort Ptr GByteArray
array' FunPtr C_CompareFunc
compareFunc'
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_CompareFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareFunc
compareFunc'
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_sort_with_data" g_byte_array_sort_with_data ::
Ptr GByteArray ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
IO ()
byteArraySortWithData ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> GLib.Callbacks.CompareDataFunc
-> m ()
byteArraySortWithData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> C_CompareFunc -> m ()
byteArraySortWithData ByteString
array C_CompareFunc
compareFunc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
FunPtr C_CompareDataFunc
compareFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (C_CompareFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc C_CompareFunc
compareFunc))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr GByteArray -> FunPtr C_CompareDataFunc -> Ptr () -> IO ()
g_byte_array_sort_with_data Ptr GByteArray
array' FunPtr C_CompareDataFunc
compareFunc' Ptr ()
forall a. Ptr a
userData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_CompareDataFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
compareFunc'
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_steal" g_byte_array_steal ::
Ptr GByteArray ->
Ptr FCT.CSize ->
IO Word8
byteArraySteal ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m ((Word8, FCT.CSize))
byteArraySteal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m (Word8, CSize)
byteArraySteal ByteString
array = IO (Word8, CSize) -> m (Word8, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word8, CSize) -> m (Word8, CSize))
-> IO (Word8, CSize) -> m (Word8, CSize)
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr CSize
len <- IO (Ptr CSize)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr FCT.CSize)
Word8
result <- Ptr GByteArray -> Ptr CSize -> IO Word8
g_byte_array_steal Ptr GByteArray
array' Ptr CSize
len
CSize
len' <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek Ptr CSize
len
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
Ptr CSize -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CSize
len
(Word8, CSize) -> IO (Word8, CSize)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
result, CSize
len')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_byte_array_unref" g_byte_array_unref ::
Ptr GByteArray ->
IO ()
byteArrayUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m ()
byteArrayUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m ()
byteArrayUnref ByteString
array = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr GByteArray
array' <- ByteString -> IO (Ptr GByteArray)
packGByteArray ByteString
array
Ptr GByteArray -> IO ()
g_byte_array_unref Ptr GByteArray
array'
Ptr GByteArray -> IO ()
unrefGByteArray Ptr GByteArray
array'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveByteArrayMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveByteArrayMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveByteArrayMethod t ByteArray, O.OverloadedMethod info ByteArray p) => OL.IsLabel t (ByteArray -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveByteArrayMethod t ByteArray, O.OverloadedMethod info ByteArray p, R.HasField t ByteArray p) => R.HasField t ByteArray p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveByteArrayMethod t ByteArray, O.OverloadedMethodInfo info ByteArray) => OL.IsLabel t (O.MethodProxy info ByteArray) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif