{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 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. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Soup.Structs.Buffer ( -- * Exported types Buffer(..) , newZeroBuffer , noBuffer , -- * Methods -- ** copy #method:copy# #if ENABLE_OVERLOADING BufferCopyMethodInfo , #endif bufferCopy , -- ** free #method:free# #if ENABLE_OVERLOADING BufferFreeMethodInfo , #endif bufferFree , -- ** getAsBytes #method:getAsBytes# #if ENABLE_OVERLOADING BufferGetAsBytesMethodInfo , #endif bufferGetAsBytes , -- ** getData #method:getData# #if ENABLE_OVERLOADING BufferGetDataMethodInfo , #endif bufferGetData , -- ** getOwner #method:getOwner# #if ENABLE_OVERLOADING BufferGetOwnerMethodInfo , #endif bufferGetOwner , -- ** new #method:new# bufferNew , -- ** newSubbuffer #method:newSubbuffer# #if ENABLE_OVERLOADING BufferNewSubbufferMethodInfo , #endif bufferNewSubbuffer , -- ** newWithOwner #method:newWithOwner# bufferNewWithOwner , -- * Properties -- ** data #attr:data# {- | the data -} #if ENABLE_OVERLOADING buffer_data , #endif clearBufferData , getBufferData , setBufferData , -- ** length #attr:length# {- | length of /@data@/ -} #if ENABLE_OVERLOADING buffer_length , #endif 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.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.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 import qualified GI.GLib.Callbacks as GLib.Callbacks import qualified GI.GLib.Structs.Bytes as GLib.Bytes -- | Memory-managed wrapper type. 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 -- | A convenience alias for `Nothing` :: `Maybe` `Buffer`. noBuffer :: Maybe Buffer noBuffer = Nothing {- | Get the value of the “@data@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #data @ -} getBufferData :: MonadIO m => Buffer -> m (Ptr ()) getBufferData s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO (Ptr ()) return val {- | Set the value of the “@data@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #data 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferData :: MonadIO m => Buffer -> Ptr () -> m () setBufferData s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: Ptr ()) {- | Set the value of the “@data@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #data @ -} clearBufferData :: MonadIO m => Buffer -> m () clearBufferData s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ()) #if ENABLE_OVERLOADING 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 #endif {- | Get the value of the “@length@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' buffer #length @ -} getBufferLength :: MonadIO m => Buffer -> m Word64 getBufferLength s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 8) :: IO Word64 return val {- | Set the value of the “@length@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' buffer [ #length 'Data.GI.Base.Attributes.:=' value ] @ -} setBufferLength :: MonadIO m => Buffer -> Word64 -> m () setBufferLength s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (val :: Word64) #if ENABLE_OVERLOADING 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 #endif #if ENABLE_OVERLOADING instance O.HasAttributeList Buffer type instance O.AttributeList Buffer = BufferAttributeList type BufferAttributeList = ('[ '("data", BufferDataFieldInfo), '("length", BufferLengthFieldInfo)] :: [(Symbol, *)]) #endif -- 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' #if ENABLE_OVERLOADING #endif -- 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: \\ 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_ maybeOwnerDnotify <- case ownerDnotify of Nothing -> return (castPtrToFunPtr nullPtr) Just jOwnerDnotify -> do ptrownerDnotify <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify)) 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' #if ENABLE_OVERLOADING #endif -- 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' #if ENABLE_OVERLOADING data BufferCopyMethodInfo instance (signature ~ (m Buffer), MonadIO m) => O.MethodInfo BufferCopyMethodInfo Buffer signature where overloadedMethod _ = bufferCopy #endif -- 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 () #if ENABLE_OVERLOADING data BufferFreeMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BufferFreeMethodInfo Buffer signature where overloadedMethod _ = bufferFree #endif -- 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' #if ENABLE_OVERLOADING data BufferGetAsBytesMethodInfo instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m) => O.MethodInfo BufferGetAsBytesMethodInfo Buffer signature where overloadedMethod _ = bufferGetAsBytes #endif -- 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_'' #if ENABLE_OVERLOADING data BufferGetDataMethodInfo instance (signature ~ (m (ByteString)), MonadIO m) => O.MethodInfo BufferGetDataMethodInfo Buffer signature where overloadedMethod _ = bufferGetData #endif -- 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 #if ENABLE_OVERLOADING data BufferGetOwnerMethodInfo instance (signature ~ (m (Ptr ())), MonadIO m) => O.MethodInfo BufferGetOwnerMethodInfo Buffer signature where overloadedMethod _ = bufferGetOwner #endif -- 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' #if ENABLE_OVERLOADING data BufferNewSubbufferMethodInfo instance (signature ~ (Word64 -> Word64 -> m Buffer), MonadIO m) => O.MethodInfo BufferNewSubbufferMethodInfo Buffer signature where overloadedMethod _ = bufferNewSubbuffer #endif #if ENABLE_OVERLOADING 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) => OL.IsLabel t (Buffer -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif