{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

A data buffer, generally used to represent a chunk of a
'GI.Soup.Structs.MessageBody.MessageBody'.

/@data@/ is a @/char/@ because that\'s generally convenient; in some
situations you may need to cast it to @/guchar/@ or another type.
-}

module GI.Soup.Structs.Buffer
    ( 

-- * Exported types
    Buffer(..)                              ,
    newZeroBuffer                           ,
    noBuffer                                ,


 -- * Methods
-- ** copy #method:copy#
    BufferCopyMethodInfo                    ,
    bufferCopy                              ,


-- ** free #method:free#
    BufferFreeMethodInfo                    ,
    bufferFree                              ,


-- ** getAsBytes #method:getAsBytes#
    BufferGetAsBytesMethodInfo              ,
    bufferGetAsBytes                        ,


-- ** getData #method:getData#
    BufferGetDataMethodInfo                 ,
    bufferGetData                           ,


-- ** getOwner #method:getOwner#
    BufferGetOwnerMethodInfo                ,
    bufferGetOwner                          ,


-- ** new #method:new#
    bufferNew                               ,


-- ** newSubbuffer #method:newSubbuffer#
    BufferNewSubbufferMethodInfo            ,
    bufferNewSubbuffer                      ,


-- ** newWithOwner #method:newWithOwner#
    bufferNewWithOwner                      ,




 -- * Properties
-- ** data #attr:data#
    buffer_data                             ,
    clearBufferData                         ,
    getBufferData                           ,
    setBufferData                           ,


-- ** length #attr:length#
    buffer_length                           ,
    getBufferLength                         ,
    setBufferLength                         ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes

newtype Buffer = Buffer (ManagedPtr Buffer)
foreign import ccall "soup_buffer_get_type" c_soup_buffer_get_type :: 
    IO GType

instance BoxedObject Buffer where
    boxedType _ = c_soup_buffer_get_type

-- | Construct a `Buffer` struct initialized to zero.
newZeroBuffer :: MonadIO m => m Buffer
newZeroBuffer = liftIO $ callocBoxedBytes 16 >>= wrapBoxed Buffer

instance tag ~ 'AttrSet => Constructible Buffer tag where
    new _ attrs = do
        o <- newZeroBuffer
        GI.Attributes.set o attrs
        return o


noBuffer :: Maybe Buffer
noBuffer = Nothing

getBufferData :: MonadIO m => Buffer -> m (Ptr ())
getBufferData s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
    return val

setBufferData :: MonadIO m => Buffer -> Ptr () -> m ()
setBufferData s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Ptr ())

clearBufferData :: MonadIO m => Buffer -> m ()
clearBufferData s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ())

data BufferDataFieldInfo
instance AttrInfo BufferDataFieldInfo where
    type AttrAllowedOps BufferDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BufferDataFieldInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint BufferDataFieldInfo = (~) Buffer
    type AttrGetType BufferDataFieldInfo = Ptr ()
    type AttrLabel BufferDataFieldInfo = "data"
    type AttrOrigin BufferDataFieldInfo = Buffer
    attrGet _ = getBufferData
    attrSet _ = setBufferData
    attrConstruct = undefined
    attrClear _ = clearBufferData

buffer_data :: AttrLabelProxy "data"
buffer_data = AttrLabelProxy


getBufferLength :: MonadIO m => Buffer -> m Word64
getBufferLength s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word64
    return val

setBufferLength :: MonadIO m => Buffer -> Word64 -> m ()
setBufferLength s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Word64)

data BufferLengthFieldInfo
instance AttrInfo BufferLengthFieldInfo where
    type AttrAllowedOps BufferLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BufferLengthFieldInfo = (~) Word64
    type AttrBaseTypeConstraint BufferLengthFieldInfo = (~) Buffer
    type AttrGetType BufferLengthFieldInfo = Word64
    type AttrLabel BufferLengthFieldInfo = "length"
    type AttrOrigin BufferLengthFieldInfo = Buffer
    attrGet _ = getBufferLength
    attrSet _ = setBufferLength
    attrConstruct = undefined
    attrClear _ = undefined

buffer_length :: AttrLabelProxy "length"
buffer_length = AttrLabelProxy



instance O.HasAttributeList Buffer
type instance O.AttributeList Buffer = BufferAttributeList
type BufferAttributeList = ('[ '("data", BufferDataFieldInfo), '("length", BufferLengthFieldInfo)] :: [(Symbol, *)])

-- method Buffer::new
-- method type : Constructor
-- Args : [Arg {argCName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Buffer"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_buffer_new_take" soup_buffer_new_take :: 
    Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)
    Word64 ->                               -- length : TBasicType TUInt64
    IO (Ptr Buffer)

{- |
Creates a new 'GI.Soup.Structs.Buffer.Buffer' containing /@length@/ bytes from /@data@/.

This function is exactly equivalent to @/soup_buffer_new()/@ with
'GI.Soup.Enums.MemoryUseTake' as first argument; it exists mainly for
convenience and simplifying language bindings.

@since 2.32
-}
bufferNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ByteString
    {- ^ /@data@/: data -}
    -> m Buffer
    {- ^ __Returns:__ the new 'GI.Soup.Structs.Buffer.Buffer'. -}
bufferNew data_ = liftIO $ do
    let length_ = fromIntegral $ B.length data_
    data_' <- packByteString data_
    result <- soup_buffer_new_take data_' length_
    checkUnexpectedReturnNULL "bufferNew" result
    result' <- (wrapBoxed Buffer) result
    return result'

-- method Buffer::new_with_owner
-- method type : Constructor
-- Args : [Arg {argCName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointer to an object that owns @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner_dnotify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a function to free/unref @owner when\nthe buffer is freed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Buffer"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_buffer_new_with_owner" soup_buffer_new_with_owner :: 
    Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)
    Word64 ->                               -- length : TBasicType TUInt64
    Ptr () ->                               -- owner : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- owner_dnotify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO (Ptr Buffer)

{- |
Creates a new 'GI.Soup.Structs.Buffer.Buffer' containing /@length@/ bytes from /@data@/. When
the 'GI.Soup.Structs.Buffer.Buffer' is freed, it will call /@ownerDnotify@/, passing
/@owner@/ to it. You must ensure that /@data@/ will remain valid until
/@ownerDnotify@/ is called.

For example, you could use this to create a buffer containing data
returned from libxml without needing to do an extra copy:

\<informalexample>\<programlisting>
xmlDocDumpMemory (doc, &xmlbody, &len);
return soup_buffer_new_with_owner (xmlbody, len, xmlbody,
                                   (GDestroyNotify)xmlFree);
\<\/programlisting>\<\/informalexample>

In this example, /@data@/ and /@owner@/ are the same, but in other cases
they would be different (eg, /@owner@/ would be a object, and /@data@/
would be a pointer to one of the object\'s fields).
-}
bufferNewWithOwner ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ByteString
    {- ^ /@data@/: data -}
    -> Ptr ()
    {- ^ /@owner@/: pointer to an object that owns /@data@/ -}
    -> Maybe (GLib.Callbacks.DestroyNotify)
    {- ^ /@ownerDnotify@/: a function to free\/unref /@owner@/ when
the buffer is freed -}
    -> m Buffer
    {- ^ __Returns:__ the new 'GI.Soup.Structs.Buffer.Buffer'. -}
bufferNewWithOwner data_ owner ownerDnotify = liftIO $ do
    let length_ = fromIntegral $ B.length data_
    data_' <- packByteString data_
    ptrownerDnotify <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
    maybeOwnerDnotify <- case ownerDnotify of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jOwnerDnotify -> do
            jOwnerDnotify' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrownerDnotify) jOwnerDnotify)
            poke ptrownerDnotify jOwnerDnotify'
            return jOwnerDnotify'
    result <- soup_buffer_new_with_owner data_' length_ owner maybeOwnerDnotify
    checkUnexpectedReturnNULL "bufferNewWithOwner" result
    result' <- (wrapBoxed Buffer) result
    freeMem data_'
    return result'

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

foreign import ccall "soup_buffer_copy" soup_buffer_copy :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "Soup", name = "Buffer"})
    IO (Ptr Buffer)

{- |
Makes a copy of /@buffer@/. In reality, 'GI.Soup.Structs.Buffer.Buffer' is a refcounted
type, and calling 'GI.Soup.Structs.Buffer.bufferCopy' will normally just increment
the refcount on /@buffer@/ and return it. However, if /@buffer@/ was
created with @/SOUP_MEMORY_TEMPORARY/@ memory, then 'GI.Soup.Structs.Buffer.bufferCopy'
will actually return a copy of it, so that the data in the copy
will remain valid after the temporary buffer is freed.
-}
bufferCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Buffer
    {- ^ /@buffer@/: a 'GI.Soup.Structs.Buffer.Buffer' -}
    -> m Buffer
    {- ^ __Returns:__ the new (or newly-reffed) buffer -}
bufferCopy buffer = liftIO $ do
    buffer' <- unsafeManagedPtrGetPtr buffer
    result <- soup_buffer_copy buffer'
    checkUnexpectedReturnNULL "bufferCopy" result
    result' <- (wrapBoxed Buffer) result
    touchManagedPtr buffer
    return result'

data BufferCopyMethodInfo
instance (signature ~ (m Buffer), MonadIO m) => O.MethodInfo BufferCopyMethodInfo Buffer signature where
    overloadedMethod _ = bufferCopy

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

foreign import ccall "soup_buffer_free" soup_buffer_free :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "Soup", name = "Buffer"})
    IO ()

{- |
Frees /@buffer@/. (In reality, as described in the documentation for
'GI.Soup.Structs.Buffer.bufferCopy', this is actually an \"unref\" operation, and may
or may not actually free /@buffer@/.)
-}
bufferFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Buffer
    {- ^ /@buffer@/: a 'GI.Soup.Structs.Buffer.Buffer' -}
    -> m ()
bufferFree buffer = liftIO $ do
    buffer' <- unsafeManagedPtrGetPtr buffer
    soup_buffer_free buffer'
    touchManagedPtr buffer
    return ()

data BufferFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BufferFreeMethodInfo Buffer signature where
    overloadedMethod _ = bufferFree

-- method Buffer::get_as_bytes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Soup", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupBuffer", 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 "soup_buffer_get_as_bytes" soup_buffer_get_as_bytes :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "Soup", name = "Buffer"})
    IO (Ptr GLib.Bytes.Bytes)

{- |
Creates a 'GI.GLib.Structs.Bytes.Bytes' pointing to the same memory as /@buffer@/. The
'GI.GLib.Structs.Bytes.Bytes' will hold a reference on /@buffer@/ to ensure that it is not
freed while the 'GI.GLib.Structs.Bytes.Bytes' is still valid.

@since 2.40
-}
bufferGetAsBytes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Buffer
    {- ^ /@buffer@/: a 'GI.Soup.Structs.Buffer.Buffer' -}
    -> m GLib.Bytes.Bytes
    {- ^ __Returns:__ a new 'GI.GLib.Structs.Bytes.Bytes' which has the same content
as the 'GI.Soup.Structs.Buffer.Buffer'. -}
bufferGetAsBytes buffer = liftIO $ do
    buffer' <- unsafeManagedPtrGetPtr buffer
    result <- soup_buffer_get_as_bytes buffer'
    checkUnexpectedReturnNULL "bufferGetAsBytes" result
    result' <- (wrapBoxed GLib.Bytes.Bytes) result
    touchManagedPtr buffer
    return result'

data BufferGetAsBytesMethodInfo
instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m) => O.MethodInfo BufferGetAsBytesMethodInfo Buffer signature where
    overloadedMethod _ = bufferGetAsBytes

-- method Buffer::get_data
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Soup", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the pointer\nto the buffer data is stored here", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the buffer data is stored here", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the buffer data is stored here", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_buffer_get_data" soup_buffer_get_data :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "Soup", name = "Buffer"})
    Ptr (Ptr Word8) ->                      -- data : TCArray False (-1) 2 (TBasicType TUInt8)
    Ptr Word64 ->                           -- length : TBasicType TUInt64
    IO ()

{- |
This function exists for use by language bindings, because it\'s not
currently possible to get the right effect by annotating the fields
of 'GI.Soup.Structs.Buffer.Buffer'.

@since 2.32
-}
bufferGetData ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Buffer
    {- ^ /@buffer@/: a 'GI.Soup.Structs.Buffer.Buffer' -}
    -> m (ByteString)
bufferGetData buffer = liftIO $ do
    buffer' <- unsafeManagedPtrGetPtr buffer
    data_ <- allocMem :: IO (Ptr (Ptr Word8))
    length_ <- allocMem :: IO (Ptr Word64)
    soup_buffer_get_data buffer' data_ length_
    length_' <- peek length_
    data_' <- peek data_
    data_'' <- (unpackByteStringWithLength length_') data_'
    touchManagedPtr buffer
    freeMem data_
    freeMem length_
    return data_''

data BufferGetDataMethodInfo
instance (signature ~ (m (ByteString)), MonadIO m) => O.MethodInfo BufferGetDataMethodInfo Buffer signature where
    overloadedMethod _ = bufferGetData

-- method Buffer::get_owner
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Soup", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupBuffer created with soup_buffer_new_with_owner()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "soup_buffer_get_owner" soup_buffer_get_owner :: 
    Ptr Buffer ->                           -- buffer : TInterface (Name {namespace = "Soup", name = "Buffer"})
    IO (Ptr ())

{- |
Gets the \"owner\" object for a buffer created with
'GI.Soup.Structs.Buffer.bufferNewWithOwner'.
-}
bufferGetOwner ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Buffer
    {- ^ /@buffer@/: a 'GI.Soup.Structs.Buffer.Buffer' created with 'GI.Soup.Structs.Buffer.bufferNewWithOwner' -}
    -> m (Ptr ())
    {- ^ __Returns:__ the owner pointer -}
bufferGetOwner buffer = liftIO $ do
    buffer' <- unsafeManagedPtrGetPtr buffer
    result <- soup_buffer_get_owner buffer'
    touchManagedPtr buffer
    return result

data BufferGetOwnerMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.MethodInfo BufferGetOwnerMethodInfo Buffer signature where
    overloadedMethod _ = bufferGetOwner

-- method Buffer::new_subbuffer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "parent", argType = TInterface (Name {namespace = "Soup", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the parent #SoupBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "offset within @parent to start at", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes to copy from @parent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Buffer"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_buffer_new_subbuffer" soup_buffer_new_subbuffer :: 
    Ptr Buffer ->                           -- parent : TInterface (Name {namespace = "Soup", name = "Buffer"})
    Word64 ->                               -- offset : TBasicType TUInt64
    Word64 ->                               -- length : TBasicType TUInt64
    IO (Ptr Buffer)

{- |
Creates a new 'GI.Soup.Structs.Buffer.Buffer' containing /@length@/ bytes \"copied\" from
/@parent@/ starting at /@offset@/. (Normally this will not actually copy
any data, but will instead simply reference the same data as
/@parent@/ does.)
-}
bufferNewSubbuffer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Buffer
    {- ^ /@parent@/: the parent 'GI.Soup.Structs.Buffer.Buffer' -}
    -> Word64
    {- ^ /@offset@/: offset within /@parent@/ to start at -}
    -> Word64
    {- ^ /@length@/: number of bytes to copy from /@parent@/ -}
    -> m Buffer
    {- ^ __Returns:__ the new 'GI.Soup.Structs.Buffer.Buffer'. -}
bufferNewSubbuffer parent offset length_ = liftIO $ do
    parent' <- unsafeManagedPtrGetPtr parent
    result <- soup_buffer_new_subbuffer parent' offset length_
    checkUnexpectedReturnNULL "bufferNewSubbuffer" result
    result' <- (wrapBoxed Buffer) result
    touchManagedPtr parent
    return result'

data BufferNewSubbufferMethodInfo
instance (signature ~ (Word64 -> Word64 -> m Buffer), MonadIO m) => O.MethodInfo BufferNewSubbufferMethodInfo Buffer signature where
    overloadedMethod _ = bufferNewSubbuffer

type family ResolveBufferMethod (t :: Symbol) (o :: *) :: * where
    ResolveBufferMethod "copy" o = BufferCopyMethodInfo
    ResolveBufferMethod "free" o = BufferFreeMethodInfo
    ResolveBufferMethod "newSubbuffer" o = BufferNewSubbufferMethodInfo
    ResolveBufferMethod "getAsBytes" o = BufferGetAsBytesMethodInfo
    ResolveBufferMethod "getData" o = BufferGetDataMethodInfo
    ResolveBufferMethod "getOwner" o = BufferGetOwnerMethodInfo
    ResolveBufferMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBufferMethod t Buffer, O.MethodInfo info Buffer p) => O.IsLabelProxy t (Buffer -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveBufferMethod t Buffer, O.MethodInfo info Buffer p) => O.IsLabel t (Buffer -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif