{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A simple refcounted data type representing an immutable sequence of zero or
-- more bytes from an unspecified origin.
-- 
-- The purpose of a t'GI.GLib.Structs.Bytes.Bytes' 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 t'GI.GLib.Structs.Bytes.Bytes' without coordinating
-- their activities, resting assured that the byte data will not change or
-- move while they hold a reference.
-- 
-- A t'GI.GLib.Structs.Bytes.Bytes' can come from many different origins that may have
-- different procedures for freeing the memory region.  Examples are
-- memory from 'GI.GLib.Functions.malloc', from memory slices, from a t'GI.GLib.Structs.MappedFile.MappedFile' or
-- memory from other allocators.
-- 
-- t'GI.GLib.Structs.Bytes.Bytes' work well as keys in t'GI.GLib.Structs.HashTable.HashTable'. Use 'GI.GLib.Structs.Bytes.bytesEqual' and
-- 'GI.GLib.Structs.Bytes.bytesHash' as parameters to @/g_hash_table_new()/@ or @/g_hash_table_new_full()/@.
-- t'GI.GLib.Structs.Bytes.Bytes' can also be used as keys in a t'GI.GLib.Structs.Tree.Tree' by passing the 'GI.GLib.Structs.Bytes.bytesCompare'
-- function to @/g_tree_new()/@.
-- 
-- The data pointed to by this bytes must not be modified. For a mutable
-- array of bytes see t'GI.GLib.Structs.ByteArray.ByteArray'. Use 'GI.GLib.Structs.Bytes.bytesUnrefToArray' to create a
-- mutable array for a t'GI.GLib.Structs.Bytes.Bytes' sequence. To create an immutable t'GI.GLib.Structs.Bytes.Bytes' from
-- a mutable t'GI.GLib.Structs.ByteArray.ByteArray', use the 'GI.GLib.Functions.byteArrayFreeToBytes' function.
-- 
-- /Since: 2.32/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GLib.Structs.Bytes
    (

-- * Exported types
    Bytes(..)                               ,
    noBytes                                 ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveBytesMethod                      ,
#endif


-- ** compare #method:compare#

#if defined(ENABLE_OVERLOADING)
    BytesCompareMethodInfo                  ,
#endif
    bytesCompare                            ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    BytesEqualMethodInfo                    ,
#endif
    bytesEqual                              ,


-- ** getData #method:getData#

#if defined(ENABLE_OVERLOADING)
    BytesGetDataMethodInfo                  ,
#endif
    bytesGetData                            ,


-- ** getSize #method:getSize#

#if defined(ENABLE_OVERLOADING)
    BytesGetSizeMethodInfo                  ,
#endif
    bytesGetSize                            ,


-- ** hash #method:hash#

#if defined(ENABLE_OVERLOADING)
    BytesHashMethodInfo                     ,
#endif
    bytesHash                               ,


-- ** new #method:new#

    bytesNew                                ,


-- ** newFromBytes #method:newFromBytes#

#if defined(ENABLE_OVERLOADING)
    BytesNewFromBytesMethodInfo             ,
#endif
    bytesNewFromBytes                       ,


-- ** newTake #method:newTake#

    bytesNewTake                            ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    BytesRefMethodInfo                      ,
#endif
    bytesRef                                ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    BytesUnrefMethodInfo                    ,
#endif
    bytesUnref                              ,


-- ** unrefToArray #method:unrefToArray#

#if defined(ENABLE_OVERLOADING)
    BytesUnrefToArrayMethodInfo             ,
#endif
    bytesUnrefToArray                       ,


-- ** unrefToData #method:unrefToData#

#if defined(ENABLE_OVERLOADING)
    BytesUnrefToDataMethodInfo              ,
#endif
    bytesUnrefToData                        ,




    ) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 Data.Text as T
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


-- | Memory-managed wrapper type.
newtype Bytes = Bytes (ManagedPtr Bytes)
    deriving (Eq)
foreign import ccall "g_bytes_get_type" c_g_bytes_get_type ::
    IO GType

instance BoxedObject Bytes where
    boxedType _ = c_g_bytes_get_type

-- | Convert 'Bytes' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Bytes where
    toGValue o = do
        gtype <- c_g_bytes_get_type
        B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_boxed)

    fromGValue gv = do
        ptr <- B.GValue.get_boxed gv :: IO (Ptr Bytes)
        B.ManagedPtr.newBoxed Bytes ptr



-- | A convenience alias for `Nothing` :: `Maybe` `Bytes`.
noBytes :: Maybe Bytes
noBytes = Nothing


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Bytes
type instance O.AttributeList Bytes = BytesAttributeList
type BytesAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method Bytes::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "data"
--           , argType = TCArray False (-1) 1 (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "\n       the data to be used for the bytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the size of @data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "size"
--              , argType = TBasicType TUInt32
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the size of @data" , sinceVersion = Nothing }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_new" g_bytes_new ::
    Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)
    Word32 ->                               -- size : TBasicType TUInt32
    IO (Ptr Bytes)

-- | Creates a new t'GI.GLib.Structs.Bytes.Bytes' from /@data@/.
-- 
-- /@data@/ is copied. If /@size@/ is 0, /@data@/ may be 'P.Nothing'.
-- 
-- /Since: 2.32/
bytesNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (ByteString)
    -- ^ /@data@/: 
    --        the data to be used for the bytes
    -> m Bytes
    -- ^ __Returns:__ a new t'GI.GLib.Structs.Bytes.Bytes'
bytesNew data_ = liftIO $ do
    let size = case data_ of
            Nothing -> 0
            Just jData_ -> fromIntegral $ B.length jData_
    maybeData_ <- case data_ of
        Nothing -> return nullPtr
        Just jData_ -> do
            jData_' <- packByteString jData_
            return jData_'
    result <- g_bytes_new maybeData_ size
    checkUnexpectedReturnNULL "bytesNew" result
    result' <- (wrapBoxed Bytes) result
    freeMem maybeData_
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Bytes::new_take
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "data"
--           , argType = TCArray False (-1) 1 (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "\n       the data to be used for the bytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the size of @data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "size"
--              , argType = TBasicType TUInt32
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the size of @data" , sinceVersion = Nothing }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_new_take" g_bytes_new_take ::
    Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)
    Word32 ->                               -- size : TBasicType TUInt32
    IO (Ptr Bytes)

-- | Creates a new t'GI.GLib.Structs.Bytes.Bytes' from /@data@/.
-- 
-- After this call, /@data@/ belongs to the bytes and may no longer be
-- modified by the caller.  'GI.GLib.Functions.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 'GI.GLib.Functions.malloc', 'GI.GLib.Functions.malloc0' or 'GI.GLib.Functions.realloc' or by one of the many
-- functions that wrap these calls (such as @/g_new()/@, 'GI.GLib.Functions.strdup', etc).
-- 
-- For creating t'GI.GLib.Structs.Bytes.Bytes' with memory from other allocators, see
-- @/g_bytes_new_with_free_func()/@.
-- 
-- /@data@/ may be 'P.Nothing' if /@size@/ is 0.
-- 
-- /Since: 2.32/
bytesNewTake ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (ByteString)
    -- ^ /@data@/: 
    --        the data to be used for the bytes
    -> m Bytes
    -- ^ __Returns:__ a new t'GI.GLib.Structs.Bytes.Bytes'
bytesNewTake data_ = liftIO $ do
    let size = case data_ of
            Nothing -> 0
            Just jData_ -> fromIntegral $ B.length jData_
    maybeData_ <- case data_ of
        Nothing -> return nullPtr
        Just jData_ -> do
            jData_' <- packByteString jData_
            return jData_'
    result <- g_bytes_new_take maybeData_ size
    checkUnexpectedReturnNULL "bytesNewTake" result
    result' <- (wrapBoxed Bytes) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Bytes::compare
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes1"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a pointer to a #GBytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bytes2"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a pointer to a #GBytes to compare with @bytes1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_compare" g_bytes_compare ::
    Ptr Bytes ->                            -- bytes1 : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Bytes ->                            -- bytes2 : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO Int32

-- | Compares the two t'GI.GLib.Structs.Bytes.Bytes' 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/
bytesCompare ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes1@/: a pointer to a t'GI.GLib.Structs.Bytes.Bytes'
    -> Bytes
    -- ^ /@bytes2@/: a pointer to a t'GI.GLib.Structs.Bytes.Bytes' 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@/
bytesCompare bytes1 bytes2 = liftIO $ do
    bytes1' <- unsafeManagedPtrGetPtr bytes1
    bytes2' <- unsafeManagedPtrGetPtr bytes2
    result <- g_bytes_compare bytes1' bytes2'
    touchManagedPtr bytes1
    touchManagedPtr bytes2
    return result

#if defined(ENABLE_OVERLOADING)
data BytesCompareMethodInfo
instance (signature ~ (Bytes -> m Int32), MonadIO m) => O.MethodInfo BytesCompareMethodInfo Bytes signature where
    overloadedMethod = bytesCompare

#endif

-- method Bytes::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes1"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a pointer to a #GBytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bytes2"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a pointer to a #GBytes to compare with @bytes1"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_equal" g_bytes_equal ::
    Ptr Bytes ->                            -- bytes1 : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Bytes ->                            -- bytes2 : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO CInt

-- | Compares the two t'GI.GLib.Structs.Bytes.Bytes' values being pointed to and returns
-- 'P.True' if they are equal.
-- 
-- This function can be passed to @/g_hash_table_new()/@ as the /@keyEqualFunc@/
-- parameter, when using non-'P.Nothing' t'GI.GLib.Structs.Bytes.Bytes' pointers as keys in a t'GI.GLib.Structs.HashTable.HashTable'.
-- 
-- /Since: 2.32/
bytesEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes1@/: a pointer to a t'GI.GLib.Structs.Bytes.Bytes'
    -> Bytes
    -- ^ /@bytes2@/: a pointer to a t'GI.GLib.Structs.Bytes.Bytes' to compare with /@bytes1@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the two keys match.
bytesEqual bytes1 bytes2 = liftIO $ do
    bytes1' <- unsafeManagedPtrGetPtr bytes1
    bytes2' <- unsafeManagedPtrGetPtr bytes2
    result <- g_bytes_equal bytes1' bytes2'
    let result' = (/= 0) result
    touchManagedPtr bytes1
    touchManagedPtr bytes2
    return result'

#if defined(ENABLE_OVERLOADING)
data BytesEqualMethodInfo
instance (signature ~ (Bytes -> m Bool), MonadIO m) => O.MethodInfo BytesEqualMethodInfo Bytes signature where
    overloadedMethod = bytesEqual

#endif

-- method Bytes::get_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TUInt32
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to return size of byte data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "size"
--              , argType = TBasicType TUInt32
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "location to return size of byte data"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 1 (TBasicType TUInt8))
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_get_data" g_bytes_get_data ::
    Ptr Bytes ->                            -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Word32 ->                           -- size : TBasicType TUInt32
    IO (Ptr Word8)

-- | Get the byte data in the t'GI.GLib.Structs.Bytes.Bytes'. This data should not be modified.
-- 
-- This function will always return the same pointer for a given t'GI.GLib.Structs.Bytes.Bytes'.
-- 
-- 'P.Nothing' may be returned if /@size@/ is 0. This is not guaranteed, as the t'GI.GLib.Structs.Bytes.Bytes'
-- may represent an empty string with /@data@/ non-'P.Nothing' and /@size@/ as 0. 'P.Nothing' will
-- not be returned if /@size@/ is non-zero.
-- 
-- /Since: 2.32/
bytesGetData ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes@/: a t'GI.GLib.Structs.Bytes.Bytes'
    -> m (Maybe ByteString)
    -- ^ __Returns:__ 
    --          a pointer to the byte data, or 'P.Nothing'
bytesGetData bytes = liftIO $ do
    bytes' <- unsafeManagedPtrGetPtr bytes
    size <- allocMem :: IO (Ptr Word32)
    result <- g_bytes_get_data bytes' size
    size' <- peek size
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (unpackByteStringWithLength size') result'
        return result''
    touchManagedPtr bytes
    freeMem size
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data BytesGetDataMethodInfo
instance (signature ~ (m (Maybe ByteString)), MonadIO m) => O.MethodInfo BytesGetDataMethodInfo Bytes signature where
    overloadedMethod = bytesGetData

#endif

-- method Bytes::get_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_get_size" g_bytes_get_size ::
    Ptr Bytes ->                            -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO Word32

-- | Get the size of the byte data in the t'GI.GLib.Structs.Bytes.Bytes'.
-- 
-- This function will always return the same value for a given t'GI.GLib.Structs.Bytes.Bytes'.
-- 
-- /Since: 2.32/
bytesGetSize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes@/: a t'GI.GLib.Structs.Bytes.Bytes'
    -> m Word32
    -- ^ __Returns:__ the size
bytesGetSize bytes = liftIO $ do
    bytes' <- unsafeManagedPtrGetPtr bytes
    result <- g_bytes_get_size bytes'
    touchManagedPtr bytes
    return result

#if defined(ENABLE_OVERLOADING)
data BytesGetSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BytesGetSizeMethodInfo Bytes signature where
    overloadedMethod = bytesGetSize

#endif

-- method Bytes::hash
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a pointer to a #GBytes key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_hash" g_bytes_hash ::
    Ptr Bytes ->                            -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO Word32

-- | Creates an integer hash code for the byte data in the t'GI.GLib.Structs.Bytes.Bytes'.
-- 
-- This function can be passed to @/g_hash_table_new()/@ as the /@keyHashFunc@/
-- parameter, when using non-'P.Nothing' t'GI.GLib.Structs.Bytes.Bytes' pointers as keys in a t'GI.GLib.Structs.HashTable.HashTable'.
-- 
-- /Since: 2.32/
bytesHash ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes@/: a pointer to a t'GI.GLib.Structs.Bytes.Bytes' key
    -> m Word32
    -- ^ __Returns:__ a hash value corresponding to the key.
bytesHash bytes = liftIO $ do
    bytes' <- unsafeManagedPtrGetPtr bytes
    result <- g_bytes_hash bytes'
    touchManagedPtr bytes
    return result

#if defined(ENABLE_OVERLOADING)
data BytesHashMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BytesHashMethodInfo Bytes signature where
    overloadedMethod = bytesHash

#endif

-- method Bytes::new_from_bytes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "offset"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "offset which subsection starts at"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "length of subsection"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_new_from_bytes" g_bytes_new_from_bytes ::
    Ptr Bytes ->                            -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Word32 ->                               -- offset : TBasicType TUInt32
    Word32 ->                               -- length : TBasicType TUInt32
    IO (Ptr Bytes)

-- | Creates a t'GI.GLib.Structs.Bytes.Bytes' which is a subsection of another t'GI.GLib.Structs.Bytes.Bytes'. The /@offset@/ +
-- /@length@/ may not be longer than the size of /@bytes@/.
-- 
-- A reference to /@bytes@/ will be held by the newly created t'GI.GLib.Structs.Bytes.Bytes' 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 t'GI.GLib.Structs.Bytes.Bytes', then the resulting t'GI.GLib.Structs.Bytes.Bytes' will reference
-- the same t'GI.GLib.Structs.Bytes.Bytes' instead of /@bytes@/. This allows consumers to simplify the
-- usage of t'GI.GLib.Structs.Bytes.Bytes' when asynchronously writing to streams.
-- 
-- /Since: 2.32/
bytesNewFromBytes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes@/: a t'GI.GLib.Structs.Bytes.Bytes'
    -> Word32
    -- ^ /@offset@/: offset which subsection starts at
    -> Word32
    -- ^ /@length@/: length of subsection
    -> m Bytes
    -- ^ __Returns:__ a new t'GI.GLib.Structs.Bytes.Bytes'
bytesNewFromBytes bytes offset length_ = liftIO $ do
    bytes' <- unsafeManagedPtrGetPtr bytes
    result <- g_bytes_new_from_bytes bytes' offset length_
    checkUnexpectedReturnNULL "bytesNewFromBytes" result
    result' <- (wrapBoxed Bytes) result
    touchManagedPtr bytes
    return result'

#if defined(ENABLE_OVERLOADING)
data BytesNewFromBytesMethodInfo
instance (signature ~ (Word32 -> Word32 -> m Bytes), MonadIO m) => O.MethodInfo BytesNewFromBytesMethodInfo Bytes signature where
    overloadedMethod = bytesNewFromBytes

#endif

-- method Bytes::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_ref" g_bytes_ref ::
    Ptr Bytes ->                            -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO (Ptr Bytes)

-- | Increase the reference count on /@bytes@/.
-- 
-- /Since: 2.32/
bytesRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes@/: a t'GI.GLib.Structs.Bytes.Bytes'
    -> m Bytes
    -- ^ __Returns:__ the t'GI.GLib.Structs.Bytes.Bytes'
bytesRef bytes = liftIO $ do
    bytes' <- unsafeManagedPtrGetPtr bytes
    result <- g_bytes_ref bytes'
    checkUnexpectedReturnNULL "bytesRef" result
    result' <- (wrapBoxed Bytes) result
    touchManagedPtr bytes
    return result'

#if defined(ENABLE_OVERLOADING)
data BytesRefMethodInfo
instance (signature ~ (m Bytes), MonadIO m) => O.MethodInfo BytesRefMethodInfo Bytes signature where
    overloadedMethod = bytesRef

#endif

-- method Bytes::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_unref" g_bytes_unref ::
    Ptr Bytes ->                            -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO ()

-- | Releases a reference on /@bytes@/.  This may result in the bytes being
-- freed. If /@bytes@/ is 'P.Nothing', it will return immediately.
-- 
-- /Since: 2.32/
bytesUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes@/: a t'GI.GLib.Structs.Bytes.Bytes'
    -> m ()
bytesUnref bytes = liftIO $ do
    bytes' <- unsafeManagedPtrGetPtr bytes
    g_bytes_unref bytes'
    touchManagedPtr bytes
    return ()

#if defined(ENABLE_OVERLOADING)
data BytesUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BytesUnrefMethodInfo Bytes signature where
    overloadedMethod = bytesUnref

#endif

-- method Bytes::unref_to_array
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just TByteArray
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_unref_to_array" g_bytes_unref_to_array ::
    Ptr Bytes ->                            -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO (Ptr GByteArray)

-- | Unreferences the bytes, and returns a new mutable t'GI.GLib.Structs.ByteArray.ByteArray' 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
-- 'GI.GLib.Structs.Bytes.bytesNew', 'GI.GLib.Structs.Bytes.bytesNewTake' or 'GI.GLib.Functions.byteArrayFreeToBytes'. In all
-- other cases the data is copied.
-- 
-- /Since: 2.32/
bytesUnrefToArray ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes@/: a t'GI.GLib.Structs.Bytes.Bytes'
    -> m ByteString
    -- ^ __Returns:__ a new mutable t'GI.GLib.Structs.ByteArray.ByteArray' containing the same byte data
bytesUnrefToArray bytes = liftIO $ do
    bytes' <- B.ManagedPtr.disownBoxed bytes
    result <- g_bytes_unref_to_array bytes'
    checkUnexpectedReturnNULL "bytesUnrefToArray" result
    result' <- unpackGByteArray result
    unrefGByteArray result
    touchManagedPtr bytes
    return result'

#if defined(ENABLE_OVERLOADING)
data BytesUnrefToArrayMethodInfo
instance (signature ~ (m ByteString), MonadIO m) => O.MethodInfo BytesUnrefToArrayMethodInfo Bytes signature where
    overloadedMethod = bytesUnrefToArray

#endif

-- method Bytes::unref_to_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "size"
--           , argType = TBasicType TUInt32
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "location to place the length of the returned data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "size"
--              , argType = TBasicType TUInt32
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText =
--                        Just "location to place the length of the returned data"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 1 (TBasicType TUInt8))
-- throws : False
-- Skip return : False

foreign import ccall "g_bytes_unref_to_data" g_bytes_unref_to_data ::
    Ptr Bytes ->                            -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Word32 ->                           -- size : TBasicType TUInt32
    IO (Ptr Word8)

-- | 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 'GI.GLib.Structs.Bytes.bytesNew',
-- 'GI.GLib.Structs.Bytes.bytesNewTake' or 'GI.GLib.Functions.byteArrayFreeToBytes'. In all other cases the
-- data is copied.
-- 
-- /Since: 2.32/
bytesUnrefToData ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bytes
    -- ^ /@bytes@/: a t'GI.GLib.Structs.Bytes.Bytes'
    -> m ByteString
    -- ^ __Returns:__ a pointer to the same byte data, which should be
    --          freed with 'GI.GLib.Functions.free'
bytesUnrefToData bytes = liftIO $ do
    bytes' <- B.ManagedPtr.disownBoxed bytes
    size <- allocMem :: IO (Ptr Word32)
    result <- g_bytes_unref_to_data bytes' size
    size' <- peek size
    checkUnexpectedReturnNULL "bytesUnrefToData" result
    result' <- (unpackByteStringWithLength size') result
    freeMem result
    touchManagedPtr bytes
    freeMem size
    return result'

#if defined(ENABLE_OVERLOADING)
data BytesUnrefToDataMethodInfo
instance (signature ~ (m ByteString), MonadIO m) => O.MethodInfo BytesUnrefToDataMethodInfo Bytes signature where
    overloadedMethod = bytesUnrefToData

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveBytesMethod (t :: Symbol) (o :: *) :: * where
    ResolveBytesMethod "compare" o = BytesCompareMethodInfo
    ResolveBytesMethod "equal" o = BytesEqualMethodInfo
    ResolveBytesMethod "hash" o = BytesHashMethodInfo
    ResolveBytesMethod "newFromBytes" o = BytesNewFromBytesMethodInfo
    ResolveBytesMethod "ref" o = BytesRefMethodInfo
    ResolveBytesMethod "unref" o = BytesUnrefMethodInfo
    ResolveBytesMethod "unrefToArray" o = BytesUnrefToArrayMethodInfo
    ResolveBytesMethod "unrefToData" o = BytesUnrefToDataMethodInfo
    ResolveBytesMethod "getData" o = BytesGetDataMethodInfo
    ResolveBytesMethod "getSize" o = BytesGetSizeMethodInfo
    ResolveBytesMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBytesMethod t Bytes, O.MethodInfo info Bytes p) => OL.IsLabel t (Bytes -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif