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

    'GI.Gio.Objects.MemoryInputStream.MemoryInputStream' is a class for using arbitrary
    memory chunks as input for GIO streaming input operations.

    As of GLib 2.34, 'GI.Gio.Objects.MemoryInputStream.MemoryInputStream' implements
    'GI.Gio.Interfaces.PollableInputStream.PollableInputStream'.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.MemoryInputStream
        (

    -- * Exported types
        MemoryInputStream(..)                   ,
        IsMemoryInputStream                     ,
        toMemoryInputStream                     ,
        noMemoryInputStream                     ,

     -- * Methods
    -- ** addBytes #method:addBytes#

    #if ENABLE_OVERLOADING
        MemoryInputStreamAddBytesMethodInfo     ,
    #endif
        memoryInputStreamAddBytes               ,

    -- ** addData #method:addData#

    #if ENABLE_OVERLOADING
        MemoryInputStreamAddDataMethodInfo      ,
    #endif
        memoryInputStreamAddData                ,

    -- ** new #method:new#

        memoryInputStreamNew                    ,

    -- ** newFromBytes #method:newFromBytes#

        memoryInputStreamNewFromBytes           ,

    -- ** newFromData #method:newFromData#

        memoryInputStreamNewFromData            ,

        ) 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.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.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
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.PollableInputStream as Gio.PollableInputStream
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Seekable as Gio.Seekable
    import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream

    -- | Memory-managed wrapper type.
    newtype MemoryInputStream = MemoryInputStream (ManagedPtr MemoryInputStream)
    foreign import ccall "g_memory_input_stream_get_type"
        c_g_memory_input_stream_get_type :: IO GType

    instance GObject MemoryInputStream where
        gobjectType _ = c_g_memory_input_stream_get_type

    -- | Type class for types which can be safely cast to `MemoryInputStream`, for instance with `toMemoryInputStream`.
    class GObject o => IsMemoryInputStream o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError MemoryInputStream a) =>
        IsMemoryInputStream a
    #endif
    instance IsMemoryInputStream MemoryInputStream
    instance Gio.InputStream.IsInputStream MemoryInputStream
    instance GObject.Object.IsObject MemoryInputStream
    instance Gio.PollableInputStream.IsPollableInputStream MemoryInputStream
    instance Gio.Seekable.IsSeekable MemoryInputStream

    -- | Cast to `MemoryInputStream`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toMemoryInputStream :: (MonadIO m, IsMemoryInputStream o) => o -> m MemoryInputStream
    toMemoryInputStream = liftIO . unsafeCastTo MemoryInputStream

    -- | A convenience alias for `Nothing` :: `Maybe` `MemoryInputStream`.
    noMemoryInputStream :: Maybe MemoryInputStream
    noMemoryInputStream = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveMemoryInputStreamMethod (t :: Symbol) (o :: *) :: * where
        ResolveMemoryInputStreamMethod "addBytes" o = MemoryInputStreamAddBytesMethodInfo
        ResolveMemoryInputStreamMethod "addData" o = MemoryInputStreamAddDataMethodInfo
        ResolveMemoryInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveMemoryInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveMemoryInputStreamMethod "canPoll" o = Gio.PollableInputStream.PollableInputStreamCanPollMethodInfo
        ResolveMemoryInputStreamMethod "canSeek" o = Gio.Seekable.SeekableCanSeekMethodInfo
        ResolveMemoryInputStreamMethod "canTruncate" o = Gio.Seekable.SeekableCanTruncateMethodInfo
        ResolveMemoryInputStreamMethod "clearPending" o = Gio.InputStream.InputStreamClearPendingMethodInfo
        ResolveMemoryInputStreamMethod "close" o = Gio.InputStream.InputStreamCloseMethodInfo
        ResolveMemoryInputStreamMethod "closeAsync" o = Gio.InputStream.InputStreamCloseAsyncMethodInfo
        ResolveMemoryInputStreamMethod "closeFinish" o = Gio.InputStream.InputStreamCloseFinishMethodInfo
        ResolveMemoryInputStreamMethod "createSource" o = Gio.PollableInputStream.PollableInputStreamCreateSourceMethodInfo
        ResolveMemoryInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveMemoryInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveMemoryInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveMemoryInputStreamMethod "hasPending" o = Gio.InputStream.InputStreamHasPendingMethodInfo
        ResolveMemoryInputStreamMethod "isClosed" o = Gio.InputStream.InputStreamIsClosedMethodInfo
        ResolveMemoryInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveMemoryInputStreamMethod "isReadable" o = Gio.PollableInputStream.PollableInputStreamIsReadableMethodInfo
        ResolveMemoryInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveMemoryInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveMemoryInputStreamMethod "read" o = Gio.InputStream.InputStreamReadMethodInfo
        ResolveMemoryInputStreamMethod "readAll" o = Gio.InputStream.InputStreamReadAllMethodInfo
        ResolveMemoryInputStreamMethod "readAllAsync" o = Gio.InputStream.InputStreamReadAllAsyncMethodInfo
        ResolveMemoryInputStreamMethod "readAllFinish" o = Gio.InputStream.InputStreamReadAllFinishMethodInfo
        ResolveMemoryInputStreamMethod "readAsync" o = Gio.InputStream.InputStreamReadAsyncMethodInfo
        ResolveMemoryInputStreamMethod "readBytes" o = Gio.InputStream.InputStreamReadBytesMethodInfo
        ResolveMemoryInputStreamMethod "readBytesAsync" o = Gio.InputStream.InputStreamReadBytesAsyncMethodInfo
        ResolveMemoryInputStreamMethod "readBytesFinish" o = Gio.InputStream.InputStreamReadBytesFinishMethodInfo
        ResolveMemoryInputStreamMethod "readFinish" o = Gio.InputStream.InputStreamReadFinishMethodInfo
        ResolveMemoryInputStreamMethod "readNonblocking" o = Gio.PollableInputStream.PollableInputStreamReadNonblockingMethodInfo
        ResolveMemoryInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveMemoryInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveMemoryInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveMemoryInputStreamMethod "seek" o = Gio.Seekable.SeekableSeekMethodInfo
        ResolveMemoryInputStreamMethod "skip" o = Gio.InputStream.InputStreamSkipMethodInfo
        ResolveMemoryInputStreamMethod "skipAsync" o = Gio.InputStream.InputStreamSkipAsyncMethodInfo
        ResolveMemoryInputStreamMethod "skipFinish" o = Gio.InputStream.InputStreamSkipFinishMethodInfo
        ResolveMemoryInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveMemoryInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveMemoryInputStreamMethod "tell" o = Gio.Seekable.SeekableTellMethodInfo
        ResolveMemoryInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveMemoryInputStreamMethod "truncate" o = Gio.Seekable.SeekableTruncateMethodInfo
        ResolveMemoryInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveMemoryInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveMemoryInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveMemoryInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveMemoryInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveMemoryInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveMemoryInputStreamMethod "setPending" o = Gio.InputStream.InputStreamSetPendingMethodInfo
        ResolveMemoryInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveMemoryInputStreamMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveMemoryInputStreamMethod t MemoryInputStream, O.MethodInfo info MemoryInputStream p) => O.IsLabel t (MemoryInputStream -> 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

    #endif

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

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList MemoryInputStream = MemoryInputStreamSignalList
    type MemoryInputStreamSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method MemoryInputStream::new
    -- method type : Constructor
    -- Args : []
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "MemoryInputStream"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_memory_input_stream_new" g_memory_input_stream_new ::
        IO (Ptr MemoryInputStream)

    {- |
    Creates a new empty 'GI.Gio.Objects.MemoryInputStream.MemoryInputStream'.
    -}
    memoryInputStreamNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m MemoryInputStream
        {- ^ __Returns:__ a new 'GI.Gio.Objects.InputStream.InputStream' -}
    memoryInputStreamNew  = liftIO $ do
        result <- g_memory_input_stream_new
        checkUnexpectedReturnNULL "memoryInputStreamNew" result
        result' <- (wrapObject MemoryInputStream) result
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method MemoryInputStream::new_from_bytes
    -- method type : Constructor
    -- 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 = "Gio", name = "MemoryInputStream"}))
    -- throws : False
    -- Skip return : False

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

    {- |
    Creates a new 'GI.Gio.Objects.MemoryInputStream.MemoryInputStream' with data from the given /@bytes@/.

    /Since: 2.34/
    -}
    memoryInputStreamNewFromBytes ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.Bytes.Bytes
        {- ^ /@bytes@/: a 'GI.GLib.Structs.Bytes.Bytes' -}
        -> m MemoryInputStream
        {- ^ __Returns:__ new 'GI.Gio.Objects.InputStream.InputStream' read from /@bytes@/ -}
    memoryInputStreamNewFromBytes bytes = liftIO $ do
        bytes' <- unsafeManagedPtrGetPtr bytes
        result <- g_memory_input_stream_new_from_bytes bytes'
        checkUnexpectedReturnNULL "memoryInputStreamNewFromBytes" result
        result' <- (wrapObject MemoryInputStream) result
        touchManagedPtr bytes
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method MemoryInputStream::new_from_data
    -- method type : Constructor
    -- Args : [Arg {argCName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of the data, may be -1 if @data is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function that is called to free @data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of the data, may be -1 if @data is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "MemoryInputStream"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_memory_input_stream_new_from_data" g_memory_input_stream_new_from_data ::
        Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)
        Int64 ->                                -- len : TBasicType TInt64
        FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
        IO (Ptr MemoryInputStream)

    {- |
    Creates a new 'GI.Gio.Objects.MemoryInputStream.MemoryInputStream' with data in memory of a given size.
    -}
    memoryInputStreamNewFromData ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        ByteString
        {- ^ /@data@/: input data -}
        -> Maybe (GLib.Callbacks.DestroyNotify)
        {- ^ /@destroy@/: function that is called to free /@data@/, or 'Nothing' -}
        -> m MemoryInputStream
        {- ^ __Returns:__ new 'GI.Gio.Objects.InputStream.InputStream' read from /@data@/ of /@len@/ bytes. -}
    memoryInputStreamNewFromData data_ destroy = liftIO $ do
        let len = fromIntegral $ B.length data_
        data_' <- packByteString data_
        maybeDestroy <- case destroy of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jDestroy -> do
                ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
                jDestroy' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrdestroy) jDestroy)
                poke ptrdestroy jDestroy'
                return jDestroy'
        result <- g_memory_input_stream_new_from_data data_' len maybeDestroy
        checkUnexpectedReturnNULL "memoryInputStreamNewFromData" result
        result' <- (wrapObject MemoryInputStream) result
        return result'

    #if ENABLE_OVERLOADING
    #endif

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

    foreign import ccall "g_memory_input_stream_add_bytes" g_memory_input_stream_add_bytes ::
        Ptr MemoryInputStream ->                -- stream : TInterface (Name {namespace = "Gio", name = "MemoryInputStream"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        IO ()

    {- |
    Appends /@bytes@/ to data that can be read from the input stream.

    /Since: 2.34/
    -}
    memoryInputStreamAddBytes ::
        (B.CallStack.HasCallStack, MonadIO m, IsMemoryInputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.MemoryInputStream.MemoryInputStream' -}
        -> GLib.Bytes.Bytes
        {- ^ /@bytes@/: input data -}
        -> m ()
    memoryInputStreamAddBytes stream bytes = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        bytes' <- unsafeManagedPtrGetPtr bytes
        g_memory_input_stream_add_bytes stream' bytes'
        touchManagedPtr stream
        touchManagedPtr bytes
        return ()

    #if ENABLE_OVERLOADING
    data MemoryInputStreamAddBytesMethodInfo
    instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m, IsMemoryInputStream a) => O.MethodInfo MemoryInputStreamAddBytesMethodInfo a signature where
        overloadedMethod _ = memoryInputStreamAddBytes

    #endif

    -- method MemoryInputStream::add_data
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "MemoryInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMemoryInputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of the data, may be -1 if @data is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function that is called to free @data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of the data, may be -1 if @data is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_memory_input_stream_add_data" g_memory_input_stream_add_data ::
        Ptr MemoryInputStream ->                -- stream : TInterface (Name {namespace = "Gio", name = "MemoryInputStream"})
        Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
        Int64 ->                                -- len : TBasicType TInt64
        FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
        IO ()

    {- |
    Appends /@data@/ to data that can be read from the input stream
    -}
    memoryInputStreamAddData ::
        (B.CallStack.HasCallStack, MonadIO m, IsMemoryInputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.MemoryInputStream.MemoryInputStream' -}
        -> ByteString
        {- ^ /@data@/: input data -}
        -> Maybe (GLib.Callbacks.DestroyNotify)
        {- ^ /@destroy@/: function that is called to free /@data@/, or 'Nothing' -}
        -> m ()
    memoryInputStreamAddData stream data_ destroy = liftIO $ do
        let len = fromIntegral $ B.length data_
        stream' <- unsafeManagedPtrCastPtr stream
        data_' <- packByteString data_
        maybeDestroy <- case destroy of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jDestroy -> do
                ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
                jDestroy' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrdestroy) jDestroy)
                poke ptrdestroy jDestroy'
                return jDestroy'
        g_memory_input_stream_add_data stream' data_' len maybeDestroy
        touchManagedPtr stream
        return ()

    #if ENABLE_OVERLOADING
    data MemoryInputStreamAddDataMethodInfo
    instance (signature ~ (ByteString -> Maybe (GLib.Callbacks.DestroyNotify) -> m ()), MonadIO m, IsMemoryInputStream a) => O.MethodInfo MemoryInputStreamAddDataMethodInfo a signature where
        overloadedMethod _ = memoryInputStreamAddData

    #endif