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

    Data input stream implements 'GI.Gio.Objects.InputStream.InputStream' and includes functions for
    reading structured data directly from a binary input stream.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.DataInputStream
        (

    -- * Exported types
        DataInputStream(..)                     ,
        IsDataInputStream                       ,
        toDataInputStream                       ,
        noDataInputStream                       ,

     -- * Methods
    -- ** getByteOrder #method:getByteOrder#

    #if ENABLE_OVERLOADING
        DataInputStreamGetByteOrderMethodInfo   ,
    #endif
        dataInputStreamGetByteOrder             ,

    -- ** getNewlineType #method:getNewlineType#

    #if ENABLE_OVERLOADING
        DataInputStreamGetNewlineTypeMethodInfo ,
    #endif
        dataInputStreamGetNewlineType           ,

    -- ** new #method:new#

        dataInputStreamNew                      ,

    -- ** readByte #method:readByte#

    #if ENABLE_OVERLOADING
        DataInputStreamReadByteMethodInfo       ,
    #endif
        dataInputStreamReadByte                 ,

    -- ** readInt16 #method:readInt16#

    #if ENABLE_OVERLOADING
        DataInputStreamReadInt16MethodInfo      ,
    #endif
        dataInputStreamReadInt16                ,

    -- ** readInt32 #method:readInt32#

    #if ENABLE_OVERLOADING
        DataInputStreamReadInt32MethodInfo      ,
    #endif
        dataInputStreamReadInt32                ,

    -- ** readInt64 #method:readInt64#

    #if ENABLE_OVERLOADING
        DataInputStreamReadInt64MethodInfo      ,
    #endif
        dataInputStreamReadInt64                ,

    -- ** readLine #method:readLine#

    #if ENABLE_OVERLOADING
        DataInputStreamReadLineMethodInfo       ,
    #endif
        dataInputStreamReadLine                 ,

    -- ** readLineAsync #method:readLineAsync#

    #if ENABLE_OVERLOADING
        DataInputStreamReadLineAsyncMethodInfo  ,
    #endif
        dataInputStreamReadLineAsync            ,

    -- ** readLineFinish #method:readLineFinish#

    #if ENABLE_OVERLOADING
        DataInputStreamReadLineFinishMethodInfo ,
    #endif
        dataInputStreamReadLineFinish           ,

    -- ** readLineFinishUtf8 #method:readLineFinishUtf8#

    #if ENABLE_OVERLOADING
        DataInputStreamReadLineFinishUtf8MethodInfo,
    #endif
        dataInputStreamReadLineFinishUtf8       ,

    -- ** readLineUtf8 #method:readLineUtf8#

    #if ENABLE_OVERLOADING
        DataInputStreamReadLineUtf8MethodInfo   ,
    #endif
        dataInputStreamReadLineUtf8             ,

    -- ** readUint16 #method:readUint16#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUint16MethodInfo     ,
    #endif
        dataInputStreamReadUint16               ,

    -- ** readUint32 #method:readUint32#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUint32MethodInfo     ,
    #endif
        dataInputStreamReadUint32               ,

    -- ** readUint64 #method:readUint64#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUint64MethodInfo     ,
    #endif
        dataInputStreamReadUint64               ,

    -- ** readUntil #method:readUntil#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUntilMethodInfo      ,
    #endif
        dataInputStreamReadUntil                ,

    -- ** readUntilAsync #method:readUntilAsync#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUntilAsyncMethodInfo ,
    #endif
        dataInputStreamReadUntilAsync           ,

    -- ** readUntilFinish #method:readUntilFinish#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUntilFinishMethodInfo,
    #endif
        dataInputStreamReadUntilFinish          ,

    -- ** readUpto #method:readUpto#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUptoMethodInfo       ,
    #endif
        dataInputStreamReadUpto                 ,

    -- ** readUptoAsync #method:readUptoAsync#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUptoAsyncMethodInfo  ,
    #endif
        dataInputStreamReadUptoAsync            ,

    -- ** readUptoFinish #method:readUptoFinish#

    #if ENABLE_OVERLOADING
        DataInputStreamReadUptoFinishMethodInfo ,
    #endif
        dataInputStreamReadUptoFinish           ,

    -- ** setByteOrder #method:setByteOrder#

    #if ENABLE_OVERLOADING
        DataInputStreamSetByteOrderMethodInfo   ,
    #endif
        dataInputStreamSetByteOrder             ,

    -- ** setNewlineType #method:setNewlineType#

    #if ENABLE_OVERLOADING
        DataInputStreamSetNewlineTypeMethodInfo ,
    #endif
        dataInputStreamSetNewlineType           ,

     -- * Properties
    -- ** byteOrder #attr:byteOrder#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        DataInputStreamByteOrderPropertyInfo    ,
    #endif
        constructDataInputStreamByteOrder       ,
    #if ENABLE_OVERLOADING
        dataInputStreamByteOrder                ,
    #endif
        getDataInputStreamByteOrder             ,
        setDataInputStreamByteOrder             ,

    -- ** newlineType #attr:newlineType#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        DataInputStreamNewlineTypePropertyInfo  ,
    #endif
        constructDataInputStreamNewlineType     ,
    #if ENABLE_OVERLOADING
        dataInputStreamNewlineType              ,
    #endif
        getDataInputStreamNewlineType           ,
        setDataInputStreamNewlineType           ,

        ) 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.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Seekable as Gio.Seekable
    import {-# SOURCE #-} qualified GI.Gio.Objects.BufferedInputStream as Gio.BufferedInputStream
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.FilterInputStream as Gio.FilterInputStream
    import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream

    -- | Memory-managed wrapper type.
    newtype DataInputStream = DataInputStream (ManagedPtr DataInputStream)
    foreign import ccall "g_data_input_stream_get_type"
        c_g_data_input_stream_get_type :: IO GType

    instance GObject DataInputStream where
        gobjectType _ = c_g_data_input_stream_get_type

    -- | Type class for types which can be safely cast to `DataInputStream`, for instance with `toDataInputStream`.
    class GObject o => IsDataInputStream o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DataInputStream a) =>
        IsDataInputStream a
    #endif
    instance IsDataInputStream DataInputStream
    instance Gio.BufferedInputStream.IsBufferedInputStream DataInputStream
    instance Gio.FilterInputStream.IsFilterInputStream DataInputStream
    instance Gio.InputStream.IsInputStream DataInputStream
    instance GObject.Object.IsObject DataInputStream
    instance Gio.Seekable.IsSeekable DataInputStream

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

    -- | A convenience alias for `Nothing` :: `Maybe` `DataInputStream`.
    noDataInputStream :: Maybe DataInputStream
    noDataInputStream = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveDataInputStreamMethod (t :: Symbol) (o :: *) :: * where
        ResolveDataInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveDataInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveDataInputStreamMethod "canSeek" o = Gio.Seekable.SeekableCanSeekMethodInfo
        ResolveDataInputStreamMethod "canTruncate" o = Gio.Seekable.SeekableCanTruncateMethodInfo
        ResolveDataInputStreamMethod "clearPending" o = Gio.InputStream.InputStreamClearPendingMethodInfo
        ResolveDataInputStreamMethod "close" o = Gio.InputStream.InputStreamCloseMethodInfo
        ResolveDataInputStreamMethod "closeAsync" o = Gio.InputStream.InputStreamCloseAsyncMethodInfo
        ResolveDataInputStreamMethod "closeFinish" o = Gio.InputStream.InputStreamCloseFinishMethodInfo
        ResolveDataInputStreamMethod "fill" o = Gio.BufferedInputStream.BufferedInputStreamFillMethodInfo
        ResolveDataInputStreamMethod "fillAsync" o = Gio.BufferedInputStream.BufferedInputStreamFillAsyncMethodInfo
        ResolveDataInputStreamMethod "fillFinish" o = Gio.BufferedInputStream.BufferedInputStreamFillFinishMethodInfo
        ResolveDataInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveDataInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveDataInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveDataInputStreamMethod "hasPending" o = Gio.InputStream.InputStreamHasPendingMethodInfo
        ResolveDataInputStreamMethod "isClosed" o = Gio.InputStream.InputStreamIsClosedMethodInfo
        ResolveDataInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveDataInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveDataInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveDataInputStreamMethod "peek" o = Gio.BufferedInputStream.BufferedInputStreamPeekMethodInfo
        ResolveDataInputStreamMethod "peekBuffer" o = Gio.BufferedInputStream.BufferedInputStreamPeekBufferMethodInfo
        ResolveDataInputStreamMethod "read" o = Gio.InputStream.InputStreamReadMethodInfo
        ResolveDataInputStreamMethod "readAll" o = Gio.InputStream.InputStreamReadAllMethodInfo
        ResolveDataInputStreamMethod "readAllAsync" o = Gio.InputStream.InputStreamReadAllAsyncMethodInfo
        ResolveDataInputStreamMethod "readAllFinish" o = Gio.InputStream.InputStreamReadAllFinishMethodInfo
        ResolveDataInputStreamMethod "readAsync" o = Gio.InputStream.InputStreamReadAsyncMethodInfo
        ResolveDataInputStreamMethod "readByte" o = DataInputStreamReadByteMethodInfo
        ResolveDataInputStreamMethod "readBytes" o = Gio.InputStream.InputStreamReadBytesMethodInfo
        ResolveDataInputStreamMethod "readBytesAsync" o = Gio.InputStream.InputStreamReadBytesAsyncMethodInfo
        ResolveDataInputStreamMethod "readBytesFinish" o = Gio.InputStream.InputStreamReadBytesFinishMethodInfo
        ResolveDataInputStreamMethod "readFinish" o = Gio.InputStream.InputStreamReadFinishMethodInfo
        ResolveDataInputStreamMethod "readInt16" o = DataInputStreamReadInt16MethodInfo
        ResolveDataInputStreamMethod "readInt32" o = DataInputStreamReadInt32MethodInfo
        ResolveDataInputStreamMethod "readInt64" o = DataInputStreamReadInt64MethodInfo
        ResolveDataInputStreamMethod "readLine" o = DataInputStreamReadLineMethodInfo
        ResolveDataInputStreamMethod "readLineAsync" o = DataInputStreamReadLineAsyncMethodInfo
        ResolveDataInputStreamMethod "readLineFinish" o = DataInputStreamReadLineFinishMethodInfo
        ResolveDataInputStreamMethod "readLineFinishUtf8" o = DataInputStreamReadLineFinishUtf8MethodInfo
        ResolveDataInputStreamMethod "readLineUtf8" o = DataInputStreamReadLineUtf8MethodInfo
        ResolveDataInputStreamMethod "readUint16" o = DataInputStreamReadUint16MethodInfo
        ResolveDataInputStreamMethod "readUint32" o = DataInputStreamReadUint32MethodInfo
        ResolveDataInputStreamMethod "readUint64" o = DataInputStreamReadUint64MethodInfo
        ResolveDataInputStreamMethod "readUntil" o = DataInputStreamReadUntilMethodInfo
        ResolveDataInputStreamMethod "readUntilAsync" o = DataInputStreamReadUntilAsyncMethodInfo
        ResolveDataInputStreamMethod "readUntilFinish" o = DataInputStreamReadUntilFinishMethodInfo
        ResolveDataInputStreamMethod "readUpto" o = DataInputStreamReadUptoMethodInfo
        ResolveDataInputStreamMethod "readUptoAsync" o = DataInputStreamReadUptoAsyncMethodInfo
        ResolveDataInputStreamMethod "readUptoFinish" o = DataInputStreamReadUptoFinishMethodInfo
        ResolveDataInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveDataInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveDataInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveDataInputStreamMethod "seek" o = Gio.Seekable.SeekableSeekMethodInfo
        ResolveDataInputStreamMethod "skip" o = Gio.InputStream.InputStreamSkipMethodInfo
        ResolveDataInputStreamMethod "skipAsync" o = Gio.InputStream.InputStreamSkipAsyncMethodInfo
        ResolveDataInputStreamMethod "skipFinish" o = Gio.InputStream.InputStreamSkipFinishMethodInfo
        ResolveDataInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveDataInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveDataInputStreamMethod "tell" o = Gio.Seekable.SeekableTellMethodInfo
        ResolveDataInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveDataInputStreamMethod "truncate" o = Gio.Seekable.SeekableTruncateMethodInfo
        ResolveDataInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveDataInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveDataInputStreamMethod "getAvailable" o = Gio.BufferedInputStream.BufferedInputStreamGetAvailableMethodInfo
        ResolveDataInputStreamMethod "getBaseStream" o = Gio.FilterInputStream.FilterInputStreamGetBaseStreamMethodInfo
        ResolveDataInputStreamMethod "getBufferSize" o = Gio.BufferedInputStream.BufferedInputStreamGetBufferSizeMethodInfo
        ResolveDataInputStreamMethod "getByteOrder" o = DataInputStreamGetByteOrderMethodInfo
        ResolveDataInputStreamMethod "getCloseBaseStream" o = Gio.FilterInputStream.FilterInputStreamGetCloseBaseStreamMethodInfo
        ResolveDataInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveDataInputStreamMethod "getNewlineType" o = DataInputStreamGetNewlineTypeMethodInfo
        ResolveDataInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveDataInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveDataInputStreamMethod "setBufferSize" o = Gio.BufferedInputStream.BufferedInputStreamSetBufferSizeMethodInfo
        ResolveDataInputStreamMethod "setByteOrder" o = DataInputStreamSetByteOrderMethodInfo
        ResolveDataInputStreamMethod "setCloseBaseStream" o = Gio.FilterInputStream.FilterInputStreamSetCloseBaseStreamMethodInfo
        ResolveDataInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveDataInputStreamMethod "setNewlineType" o = DataInputStreamSetNewlineTypeMethodInfo
        ResolveDataInputStreamMethod "setPending" o = Gio.InputStream.InputStreamSetPendingMethodInfo
        ResolveDataInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveDataInputStreamMethod l o = O.MethodResolutionFailed l o

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

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

    -- VVV Prop "byte-order"
       -- Type: TInterface (Name {namespace = "Gio", name = "DataStreamByteOrder"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    {- |
    Get the value of the “@byte-order@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dataInputStream #byteOrder
    @
    -}
    getDataInputStreamByteOrder :: (MonadIO m, IsDataInputStream o) => o -> m Gio.Enums.DataStreamByteOrder
    getDataInputStreamByteOrder obj = liftIO $ getObjectPropertyEnum obj "byte-order"

    {- |
    Set the value of the “@byte-order@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' dataInputStream [ #byteOrder 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDataInputStreamByteOrder :: (MonadIO m, IsDataInputStream o) => o -> Gio.Enums.DataStreamByteOrder -> m ()
    setDataInputStreamByteOrder obj val = liftIO $ setObjectPropertyEnum obj "byte-order" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@byte-order@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDataInputStreamByteOrder :: (IsDataInputStream o) => Gio.Enums.DataStreamByteOrder -> IO (GValueConstruct o)
    constructDataInputStreamByteOrder val = constructObjectPropertyEnum "byte-order" val

    #if ENABLE_OVERLOADING
    data DataInputStreamByteOrderPropertyInfo
    instance AttrInfo DataInputStreamByteOrderPropertyInfo where
        type AttrAllowedOps DataInputStreamByteOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DataInputStreamByteOrderPropertyInfo = (~) Gio.Enums.DataStreamByteOrder
        type AttrBaseTypeConstraint DataInputStreamByteOrderPropertyInfo = IsDataInputStream
        type AttrGetType DataInputStreamByteOrderPropertyInfo = Gio.Enums.DataStreamByteOrder
        type AttrLabel DataInputStreamByteOrderPropertyInfo = "byte-order"
        type AttrOrigin DataInputStreamByteOrderPropertyInfo = DataInputStream
        attrGet _ = getDataInputStreamByteOrder
        attrSet _ = setDataInputStreamByteOrder
        attrConstruct _ = constructDataInputStreamByteOrder
        attrClear _ = undefined
    #endif

    -- VVV Prop "newline-type"
       -- Type: TInterface (Name {namespace = "Gio", name = "DataStreamNewlineType"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    {- |
    Get the value of the “@newline-type@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' dataInputStream #newlineType
    @
    -}
    getDataInputStreamNewlineType :: (MonadIO m, IsDataInputStream o) => o -> m Gio.Enums.DataStreamNewlineType
    getDataInputStreamNewlineType obj = liftIO $ getObjectPropertyEnum obj "newline-type"

    {- |
    Set the value of the “@newline-type@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' dataInputStream [ #newlineType 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDataInputStreamNewlineType :: (MonadIO m, IsDataInputStream o) => o -> Gio.Enums.DataStreamNewlineType -> m ()
    setDataInputStreamNewlineType obj val = liftIO $ setObjectPropertyEnum obj "newline-type" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@newline-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDataInputStreamNewlineType :: (IsDataInputStream o) => Gio.Enums.DataStreamNewlineType -> IO (GValueConstruct o)
    constructDataInputStreamNewlineType val = constructObjectPropertyEnum "newline-type" val

    #if ENABLE_OVERLOADING
    data DataInputStreamNewlineTypePropertyInfo
    instance AttrInfo DataInputStreamNewlineTypePropertyInfo where
        type AttrAllowedOps DataInputStreamNewlineTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DataInputStreamNewlineTypePropertyInfo = (~) Gio.Enums.DataStreamNewlineType
        type AttrBaseTypeConstraint DataInputStreamNewlineTypePropertyInfo = IsDataInputStream
        type AttrGetType DataInputStreamNewlineTypePropertyInfo = Gio.Enums.DataStreamNewlineType
        type AttrLabel DataInputStreamNewlineTypePropertyInfo = "newline-type"
        type AttrOrigin DataInputStreamNewlineTypePropertyInfo = DataInputStream
        attrGet _ = getDataInputStreamNewlineType
        attrSet _ = setDataInputStreamNewlineType
        attrConstruct _ = constructDataInputStreamNewlineType
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList DataInputStream
    type instance O.AttributeList DataInputStream = DataInputStreamAttributeList
    type DataInputStreamAttributeList = ('[ '("baseStream", Gio.FilterInputStream.FilterInputStreamBaseStreamPropertyInfo), '("bufferSize", Gio.BufferedInputStream.BufferedInputStreamBufferSizePropertyInfo), '("byteOrder", DataInputStreamByteOrderPropertyInfo), '("closeBaseStream", Gio.FilterInputStream.FilterInputStreamCloseBaseStreamPropertyInfo), '("newlineType", DataInputStreamNewlineTypePropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    dataInputStreamByteOrder :: AttrLabelProxy "byteOrder"
    dataInputStreamByteOrder = AttrLabelProxy

    dataInputStreamNewlineType :: AttrLabelProxy "newlineType"
    dataInputStreamNewlineType = AttrLabelProxy

    #endif

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

    #endif

    -- method DataInputStream::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "base_stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DataInputStream"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_data_input_stream_new" g_data_input_stream_new ::
        Ptr Gio.InputStream.InputStream ->      -- base_stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        IO (Ptr DataInputStream)

    {- |
    Creates a new data input stream for the /@baseStream@/.
    -}
    dataInputStreamNew ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a) =>
        a
        {- ^ /@baseStream@/: a 'GI.Gio.Objects.InputStream.InputStream'. -}
        -> m DataInputStream
        {- ^ __Returns:__ a new 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
    dataInputStreamNew baseStream = liftIO $ do
        baseStream' <- unsafeManagedPtrCastPtr baseStream
        result <- g_data_input_stream_new baseStream'
        checkUnexpectedReturnNULL "dataInputStreamNew" result
        result' <- (wrapObject DataInputStream) result
        touchManagedPtr baseStream
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method DataInputStream::get_byte_order
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DataStreamByteOrder"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_data_input_stream_get_byte_order" g_data_input_stream_get_byte_order ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        IO CUInt

    {- |
    Gets the byte order for the data input stream.
    -}
    dataInputStreamGetByteOrder ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> m Gio.Enums.DataStreamByteOrder
        {- ^ __Returns:__ the /@stream@/\'s current 'GI.Gio.Enums.DataStreamByteOrder'. -}
    dataInputStreamGetByteOrder stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_data_input_stream_get_byte_order stream'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data DataInputStreamGetByteOrderMethodInfo
    instance (signature ~ (m Gio.Enums.DataStreamByteOrder), MonadIO m, IsDataInputStream a) => O.MethodInfo DataInputStreamGetByteOrderMethodInfo a signature where
        overloadedMethod _ = dataInputStreamGetByteOrder

    #endif

    -- method DataInputStream::get_newline_type
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DataStreamNewlineType"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_data_input_stream_get_newline_type" g_data_input_stream_get_newline_type ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        IO CUInt

    {- |
    Gets the current newline type for the /@stream@/.
    -}
    dataInputStreamGetNewlineType ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> m Gio.Enums.DataStreamNewlineType
        {- ^ __Returns:__ 'GI.Gio.Enums.DataStreamNewlineType' for the given /@stream@/. -}
    dataInputStreamGetNewlineType stream = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result <- g_data_input_stream_get_newline_type stream'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr stream
        return result'

    #if ENABLE_OVERLOADING
    data DataInputStreamGetNewlineTypeMethodInfo
    instance (signature ~ (m Gio.Enums.DataStreamNewlineType), MonadIO m, IsDataInputStream a) => O.MethodInfo DataInputStreamGetNewlineTypeMethodInfo a signature where
        overloadedMethod _ = dataInputStreamGetNewlineType

    #endif

    -- method DataInputStream::read_byte
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt8)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_byte" g_data_input_stream_read_byte ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Word8

    {- |
    Reads an unsigned 8-bit\/1-byte value from /@stream@/.
    -}
    dataInputStreamReadByte ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Word8
        {- ^ __Returns:__ an unsigned 8-bit\/1-byte value read from the /@stream@/ or @0@
    if an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadByte stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_byte stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadByteMethodInfo
    instance (signature ~ (Maybe (b) -> m Word8), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadByteMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadByte

    #endif

    -- method DataInputStream::read_int16
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt16)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_int16" g_data_input_stream_read_int16 ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Int16

    {- |
    Reads a 16-bit\/2-byte value from /@stream@/.

    In order to get the correct byte order for this read operation,
    see 'GI.Gio.Objects.DataInputStream.dataInputStreamGetByteOrder' and 'GI.Gio.Objects.DataInputStream.dataInputStreamSetByteOrder'.
    -}
    dataInputStreamReadInt16 ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Int16
        {- ^ __Returns:__ a signed 16-bit\/2-byte value read from /@stream@/ or @0@ if
    an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadInt16 stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_int16 stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadInt16MethodInfo
    instance (signature ~ (Maybe (b) -> m Int16), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadInt16MethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadInt16

    #endif

    -- method DataInputStream::read_int32
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt32)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_int32" g_data_input_stream_read_int32 ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Int32

    {- |
    Reads a signed 32-bit\/4-byte value from /@stream@/.

    In order to get the correct byte order for this read operation,
    see 'GI.Gio.Objects.DataInputStream.dataInputStreamGetByteOrder' and 'GI.Gio.Objects.DataInputStream.dataInputStreamSetByteOrder'.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.
    -}
    dataInputStreamReadInt32 ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Int32
        {- ^ __Returns:__ a signed 32-bit\/4-byte value read from the /@stream@/ or @0@ if
    an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadInt32 stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_int32 stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadInt32MethodInfo
    instance (signature ~ (Maybe (b) -> m Int32), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadInt32MethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadInt32

    #endif

    -- method DataInputStream::read_int64
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_int64" g_data_input_stream_read_int64 ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Int64

    {- |
    Reads a 64-bit\/8-byte value from /@stream@/.

    In order to get the correct byte order for this read operation,
    see 'GI.Gio.Objects.DataInputStream.dataInputStreamGetByteOrder' and 'GI.Gio.Objects.DataInputStream.dataInputStreamSetByteOrder'.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.
    -}
    dataInputStreamReadInt64 ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Int64
        {- ^ __Returns:__ a signed 64-bit\/8-byte value read from /@stream@/ or @0@ if
    an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadInt64 stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_int64 stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadInt64MethodInfo
    instance (signature ~ (Maybe (b) -> m Int64), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadInt64MethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadInt64

    #endif

    -- method DataInputStream::read_line
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", 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 "a #gsize to get the length of the data read in.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TCArray True (-1) (-1) (TBasicType TUInt8))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_line" g_data_input_stream_read_line ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Word8)

    {- |
    Reads a line from the data input stream.  Note that no encoding
    checks or conversion is performed; the input is not guaranteed to
    be UTF-8, and may in fact have embedded NUL characters.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.
    -}
    dataInputStreamReadLine ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m ((Maybe ByteString, Word64))
        {- ^ __Returns:__
     a NUL terminated byte array with the line that was read in
     (without the newlines).  Set /@length@/ to a @/gsize/@ to get the length
     of the read line.  On an error, it will return 'Nothing' and /@error@/
     will be set. If there\'s no content to read, it will still return
     'Nothing', but /@error@/ won\'t be set. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadLine stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        length_ <- allocMem :: IO (Ptr Word64)
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_line stream' length_ maybeCancellable
            maybeResult <- convertIfNonNull result $ \result' -> do
                result'' <- unpackZeroTerminatedByteString result'
                freeMem result'
                return result''
            length_' <- peek length_
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem length_
            return (maybeResult, length_')
         ) (do
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadLineMethodInfo
    instance (signature ~ (Maybe (b) -> m ((Maybe ByteString, Word64))), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadLineMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadLine

    #endif

    -- method DataInputStream::read_line_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_line_async" g_data_input_stream_read_line_async ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    The asynchronous version of 'GI.Gio.Objects.DataInputStream.dataInputStreamReadLine'.  It is
    an error to have two outstanding calls to this function.

    When the operation is finished, /@callback@/ will be called. You
    can then call 'GI.Gio.Objects.DataInputStream.dataInputStreamReadLineFinish' to get
    the result of the operation.

    /Since: 2.20/
    -}
    dataInputStreamReadLineAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied. -}
        -> m ()
    dataInputStreamReadLineAsync stream ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_data_input_stream_read_line_async stream' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data DataInputStreamReadLineAsyncMethodInfo
    instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadLineAsyncMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadLineAsync

    #endif

    -- method DataInputStream::read_line_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult that was provided to the callback.", 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 "a #gsize to get the length of the data read in.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TCArray True (-1) (-1) (TBasicType TUInt8))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_line_finish" g_data_input_stream_read_line_finish ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Word8)

    {- |
    Finish an asynchronous call started by
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadLineAsync'.  Note the warning about
    string encoding in 'GI.Gio.Objects.DataInputStream.dataInputStreamReadLine' applies here as
    well.

    /Since: 2.20/
    -}
    dataInputStreamReadLineFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> b
        {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' that was provided to the callback. -}
        -> m ((Maybe ByteString, Word64))
        {- ^ __Returns:__
     a NUL-terminated byte array with the line that was read in
     (without the newlines).  Set /@length@/ to a @/gsize/@ to get the length
     of the read line.  On an error, it will return 'Nothing' and /@error@/
     will be set. If there\'s no content to read, it will still return
     'Nothing', but /@error@/ won\'t be set. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadLineFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        length_ <- allocMem :: IO (Ptr Word64)
        onException (do
            result <- propagateGError $ g_data_input_stream_read_line_finish stream' result_' length_
            maybeResult <- convertIfNonNull result $ \result' -> do
                result'' <- unpackZeroTerminatedByteString result'
                freeMem result'
                return result''
            length_' <- peek length_
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem length_
            return (maybeResult, length_')
         ) (do
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadLineFinishMethodInfo
    instance (signature ~ (b -> m ((Maybe ByteString, Word64))), MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DataInputStreamReadLineFinishMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadLineFinish

    #endif

    -- method DataInputStream::read_line_finish_utf8
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult that was provided to the callback.", 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 "a #gsize to get the length of the data read in.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_line_finish_utf8" g_data_input_stream_read_line_finish_utf8 ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CString

    {- |
    Finish an asynchronous call started by
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadLineAsync'.

    /Since: 2.30/
    -}
    dataInputStreamReadLineFinishUtf8 ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> b
        {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' that was provided to the callback. -}
        -> m ((Maybe T.Text, Word64))
        {- ^ __Returns:__ a string with the line that
     was read in (without the newlines).  Set /@length@/ to a @/gsize/@ to
     get the length of the read line.  On an error, it will return
     'Nothing' and /@error@/ will be set. For UTF-8 conversion errors, the set
     error domain is @/G_CONVERT_ERROR/@.  If there\'s no content to read,
     it will still return 'Nothing', but /@error@/ won\'t be set. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadLineFinishUtf8 stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        length_ <- allocMem :: IO (Ptr Word64)
        onException (do
            result <- propagateGError $ g_data_input_stream_read_line_finish_utf8 stream' result_' length_
            maybeResult <- convertIfNonNull result $ \result' -> do
                result'' <- cstringToText result'
                freeMem result'
                return result''
            length_' <- peek length_
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem length_
            return (maybeResult, length_')
         ) (do
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadLineFinishUtf8MethodInfo
    instance (signature ~ (b -> m ((Maybe T.Text, Word64))), MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DataInputStreamReadLineFinishUtf8MethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadLineFinishUtf8

    #endif

    -- method DataInputStream::read_line_utf8
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", 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 "a #gsize to get the length of the data read in.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_line_utf8" g_data_input_stream_read_line_utf8 ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CString

    {- |
    Reads a UTF-8 encoded line from the data input stream.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.

    /Since: 2.30/
    -}
    dataInputStreamReadLineUtf8 ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m ((Maybe T.Text, Word64))
        {- ^ __Returns:__ a NUL terminated UTF-8 string
     with the line that was read in (without the newlines).  Set
     /@length@/ to a @/gsize/@ to get the length of the read line.  On an
     error, it will return 'Nothing' and /@error@/ will be set.  For UTF-8
     conversion errors, the set error domain is @/G_CONVERT_ERROR/@.  If
     there\'s no content to read, it will still return 'Nothing', but /@error@/
     won\'t be set. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadLineUtf8 stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        length_ <- allocMem :: IO (Ptr Word64)
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_line_utf8 stream' length_ maybeCancellable
            maybeResult <- convertIfNonNull result $ \result' -> do
                result'' <- cstringToText result'
                freeMem result'
                return result''
            length_' <- peek length_
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem length_
            return (maybeResult, length_')
         ) (do
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadLineUtf8MethodInfo
    instance (signature ~ (Maybe (b) -> m ((Maybe T.Text, Word64))), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadLineUtf8MethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadLineUtf8

    #endif

    -- method DataInputStream::read_uint16
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt16)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_uint16" g_data_input_stream_read_uint16 ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Word16

    {- |
    Reads an unsigned 16-bit\/2-byte value from /@stream@/.

    In order to get the correct byte order for this read operation,
    see 'GI.Gio.Objects.DataInputStream.dataInputStreamGetByteOrder' and 'GI.Gio.Objects.DataInputStream.dataInputStreamSetByteOrder'.
    -}
    dataInputStreamReadUint16 ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Word16
        {- ^ __Returns:__ an unsigned 16-bit\/2-byte value read from the /@stream@/ or @0@ if
    an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadUint16 stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_uint16 stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUint16MethodInfo
    instance (signature ~ (Maybe (b) -> m Word16), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadUint16MethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUint16

    #endif

    -- method DataInputStream::read_uint32
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt32)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_uint32" g_data_input_stream_read_uint32 ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Word32

    {- |
    Reads an unsigned 32-bit\/4-byte value from /@stream@/.

    In order to get the correct byte order for this read operation,
    see 'GI.Gio.Objects.DataInputStream.dataInputStreamGetByteOrder' and 'GI.Gio.Objects.DataInputStream.dataInputStreamSetByteOrder'.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.
    -}
    dataInputStreamReadUint32 ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Word32
        {- ^ __Returns:__ an unsigned 32-bit\/4-byte value read from the /@stream@/ or @0@ if
    an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadUint32 stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_uint32 stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUint32MethodInfo
    instance (signature ~ (Maybe (b) -> m Word32), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadUint32MethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUint32

    #endif

    -- method DataInputStream::read_uint64
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt64)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_uint64" g_data_input_stream_read_uint64 ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO Word64

    {- |
    Reads an unsigned 64-bit\/8-byte value from /@stream@/.

    In order to get the correct byte order for this read operation,
    see 'GI.Gio.Objects.DataInputStream.dataInputStreamGetByteOrder'.

    If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by
    triggering the cancellable object from another thread. If the operation
    was cancelled, the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned.
    -}
    dataInputStreamReadUint64 ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m Word64
        {- ^ __Returns:__ an unsigned 64-bit\/8-byte read from /@stream@/ or @0@ if
    an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadUint64 stream cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_uint64 stream' maybeCancellable
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            return result
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUint64MethodInfo
    instance (signature ~ (Maybe (b) -> m Word64), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadUint64MethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUint64

    #endif

    -- method DataInputStream::read_until
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "characters to terminate the read.", 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 "a #gsize to get the length of the data read in.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_until" g_data_input_stream_read_until ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        CString ->                              -- stop_chars : TBasicType TUTF8
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CString

    {-# DEPRECATED dataInputStreamReadUntil ["(Since version 2.56)","Use 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUpto' instead, which has more","    consistent behaviour regarding the stop character."] #-}
    {- |
    Reads a string from the data input stream, up to the first
    occurrence of any of the stop characters.

    Note that, in contrast to 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntilAsync',
    this function consumes the stop character that it finds.

    Don\'t use this function in new code.  Its functionality is
    inconsistent with 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntilAsync'.  Both
    functions will be marked as deprecated in a future release.  Use
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadUpto' instead, but note that that function
    does not consume the stop character.
    -}
    dataInputStreamReadUntil ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> T.Text
        {- ^ /@stopChars@/: characters to terminate the read. -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> m ((T.Text, Word64))
        {- ^ __Returns:__ a string with the data that was read
        before encountering any of the stop characters. Set /@length@/ to
        a @/gsize/@ to get the length of the string. This function will
        return 'Nothing' on an error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadUntil stream stopChars cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        stopChars' <- textToCString stopChars
        length_ <- allocMem :: IO (Ptr Word64)
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_until stream' stopChars' length_ maybeCancellable
            checkUnexpectedReturnNULL "dataInputStreamReadUntil" result
            result' <- cstringToText result
            freeMem result
            length_' <- peek length_
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem stopChars'
            freeMem length_
            return (result', length_')
         ) (do
            freeMem stopChars'
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUntilMethodInfo
    instance (signature ~ (T.Text -> Maybe (b) -> m ((T.Text, Word64))), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadUntilMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUntil

    #endif

    -- method DataInputStream::read_until_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "characters to terminate the read.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_until_async" g_data_input_stream_read_until_async ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        CString ->                              -- stop_chars : TBasicType TUTF8
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {-# DEPRECATED dataInputStreamReadUntilAsync ["(Since version 2.56)","Use 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoAsync' instead, which","    has more consistent behaviour regarding the stop character."] #-}
    {- |
    The asynchronous version of 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntil'.
    It is an error to have two outstanding calls to this function.

    Note that, in contrast to 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntil',
    this function does not consume the stop character that it finds.  You
    must read it for yourself.

    When the operation is finished, /@callback@/ will be called. You
    can then call 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntilFinish' to get
    the result of the operation.

    Don\'t use this function in new code.  Its functionality is
    inconsistent with 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntil'.  Both functions
    will be marked as deprecated in a future release.  Use
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoAsync' instead.

    /Since: 2.20/
    -}
    dataInputStreamReadUntilAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> T.Text
        {- ^ /@stopChars@/: characters to terminate the read. -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied. -}
        -> m ()
    dataInputStreamReadUntilAsync stream stopChars ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        stopChars' <- textToCString stopChars
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_data_input_stream_read_until_async stream' stopChars' ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem stopChars'
        return ()

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUntilAsyncMethodInfo
    instance (signature ~ (T.Text -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadUntilAsyncMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUntilAsync

    #endif

    -- method DataInputStream::read_until_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult that was provided to the callback.", 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 "a #gsize to get the length of the data read in.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_until_finish" g_data_input_stream_read_until_finish ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CString

    {-# DEPRECATED dataInputStreamReadUntilFinish ["(Since version 2.56)","Use 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoFinish' instead, which","    has more consistent behaviour regarding the stop character."] #-}
    {- |
    Finish an asynchronous call started by
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntilAsync'.

    /Since: 2.20/
    -}
    dataInputStreamReadUntilFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> b
        {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' that was provided to the callback. -}
        -> m ((T.Text, Word64))
        {- ^ __Returns:__ a string with the data that was read
        before encountering any of the stop characters. Set /@length@/ to
        a @/gsize/@ to get the length of the string. This function will
        return 'Nothing' on an error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadUntilFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        length_ <- allocMem :: IO (Ptr Word64)
        onException (do
            result <- propagateGError $ g_data_input_stream_read_until_finish stream' result_' length_
            checkUnexpectedReturnNULL "dataInputStreamReadUntilFinish" result
            result' <- cstringToText result
            freeMem result
            length_' <- peek length_
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem length_
            return (result', length_')
         ) (do
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUntilFinishMethodInfo
    instance (signature ~ (b -> m ((T.Text, Word64))), MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DataInputStreamReadUntilFinishMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUntilFinish

    #endif

    -- method DataInputStream::read_upto
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDataInputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "characters to terminate the read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_chars_len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @stop_chars. May be -1 if @stop_chars is\n    nul-terminated", 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 "a #gsize to get the length of the data read in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_upto" g_data_input_stream_read_upto ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        CString ->                              -- stop_chars : TBasicType TUTF8
        Int64 ->                                -- stop_chars_len : TBasicType TInt64
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CString

    {- |
    Reads a string from the data input stream, up to the first
    occurrence of any of the stop characters.

    In contrast to 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntil', this function
    does not consume the stop character. You have to use
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadByte' to get it before calling
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadUpto' again.

    Note that /@stopChars@/ may contain \'\\0\' if /@stopCharsLen@/ is
    specified.

    The returned string will always be nul-terminated on success.

    /Since: 2.26/
    -}
    dataInputStreamReadUpto ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.DataInputStream.DataInputStream' -}
        -> T.Text
        {- ^ /@stopChars@/: characters to terminate the read -}
        -> Int64
        {- ^ /@stopCharsLen@/: length of /@stopChars@/. May be -1 if /@stopChars@/ is
        nul-terminated -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
        -> m ((T.Text, Word64))
        {- ^ __Returns:__ a string with the data that was read
        before encountering any of the stop characters. Set /@length@/ to
        a @/gsize/@ to get the length of the string. This function will
        return 'Nothing' on an error /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadUpto stream stopChars stopCharsLen cancellable = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        stopChars' <- textToCString stopChars
        length_ <- allocMem :: IO (Ptr Word64)
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            result <- propagateGError $ g_data_input_stream_read_upto stream' stopChars' stopCharsLen length_ maybeCancellable
            checkUnexpectedReturnNULL "dataInputStreamReadUpto" result
            result' <- cstringToText result
            freeMem result
            length_' <- peek length_
            touchManagedPtr stream
            whenJust cancellable touchManagedPtr
            freeMem stopChars'
            freeMem length_
            return (result', length_')
         ) (do
            freeMem stopChars'
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUptoMethodInfo
    instance (signature ~ (T.Text -> Int64 -> Maybe (b) -> m ((T.Text, Word64))), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadUptoMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUpto

    #endif

    -- method DataInputStream::read_upto_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDataInputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "characters to terminate the read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_chars_len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @stop_chars. May be -1 if @stop_chars is\n    nul-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_upto_async" g_data_input_stream_read_upto_async ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        CString ->                              -- stop_chars : TBasicType TUTF8
        Int64 ->                                -- stop_chars_len : TBasicType TInt64
        Int32 ->                                -- io_priority : TBasicType TInt
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    The asynchronous version of 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUpto'.
    It is an error to have two outstanding calls to this function.

    In contrast to 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUntil', this function
    does not consume the stop character. You have to use
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadByte' to get it before calling
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadUpto' again.

    Note that /@stopChars@/ may contain \'\\0\' if /@stopCharsLen@/ is
    specified.

    When the operation is finished, /@callback@/ will be called. You
    can then call 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoFinish' to get
    the result of the operation.

    /Since: 2.26/
    -}
    dataInputStreamReadUptoAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.DataInputStream.DataInputStream' -}
        -> T.Text
        {- ^ /@stopChars@/: characters to terminate the read -}
        -> Int64
        {- ^ /@stopCharsLen@/: length of /@stopChars@/. May be -1 if /@stopChars@/ is
        nul-terminated -}
        -> Int32
        {- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
        -> Maybe (b)
        {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: callback to call when the request is satisfied -}
        -> m ()
    dataInputStreamReadUptoAsync stream stopChars stopCharsLen ioPriority cancellable callback = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        stopChars' <- textToCString stopChars
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_data_input_stream_read_upto_async stream' stopChars' stopCharsLen ioPriority maybeCancellable maybeCallback userData
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        freeMem stopChars'
        return ()

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUptoAsyncMethodInfo
    instance (signature ~ (T.Text -> Int64 -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DataInputStreamReadUptoAsyncMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUptoAsync

    #endif

    -- method DataInputStream::read_upto_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDataInputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult that was provided to the callback", 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 "a #gsize to get the length of the data read in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_data_input_stream_read_upto_finish" g_data_input_stream_read_upto_finish ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CString

    {- |
    Finish an asynchronous call started by
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoAsync'.

    Note that this function does not consume the stop character. You
    have to use 'GI.Gio.Objects.DataInputStream.dataInputStreamReadByte' to get it before calling
    'GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoAsync' again.

    The returned string will always be nul-terminated on success.

    /Since: 2.24/
    -}
    dataInputStreamReadUptoFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.DataInputStream.DataInputStream' -}
        -> b
        {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' that was provided to the callback -}
        -> m ((T.Text, Word64))
        {- ^ __Returns:__ a string with the data that was read
        before encountering any of the stop characters. Set /@length@/ to
        a @/gsize/@ to get the length of the string. This function will
        return 'Nothing' on an error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dataInputStreamReadUptoFinish stream result_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        result_' <- unsafeManagedPtrCastPtr result_
        length_ <- allocMem :: IO (Ptr Word64)
        onException (do
            result <- propagateGError $ g_data_input_stream_read_upto_finish stream' result_' length_
            checkUnexpectedReturnNULL "dataInputStreamReadUptoFinish" result
            result' <- cstringToText result
            freeMem result
            length_' <- peek length_
            touchManagedPtr stream
            touchManagedPtr result_
            freeMem length_
            return (result', length_')
         ) (do
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data DataInputStreamReadUptoFinishMethodInfo
    instance (signature ~ (b -> m ((T.Text, Word64))), MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DataInputStreamReadUptoFinishMethodInfo a signature where
        overloadedMethod _ = dataInputStreamReadUptoFinish

    #endif

    -- method DataInputStream::set_byte_order
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a given #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "order", argType = TInterface (Name {namespace = "Gio", name = "DataStreamByteOrder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDataStreamByteOrder to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_data_input_stream_set_byte_order" g_data_input_stream_set_byte_order ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        CUInt ->                                -- order : TInterface (Name {namespace = "Gio", name = "DataStreamByteOrder"})
        IO ()

    {- |
    This function sets the byte order for the given /@stream@/. All subsequent
    reads from the /@stream@/ will be read in the given /@order@/.
    -}
    dataInputStreamSetByteOrder ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a) =>
        a
        {- ^ /@stream@/: a given 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Gio.Enums.DataStreamByteOrder
        {- ^ /@order@/: a 'GI.Gio.Enums.DataStreamByteOrder' to set. -}
        -> m ()
    dataInputStreamSetByteOrder stream order = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        let order' = (fromIntegral . fromEnum) order
        g_data_input_stream_set_byte_order stream' order'
        touchManagedPtr stream
        return ()

    #if ENABLE_OVERLOADING
    data DataInputStreamSetByteOrderMethodInfo
    instance (signature ~ (Gio.Enums.DataStreamByteOrder -> m ()), MonadIO m, IsDataInputStream a) => O.MethodInfo DataInputStreamSetByteOrderMethodInfo a signature where
        overloadedMethod _ = dataInputStreamSetByteOrder

    #endif

    -- method DataInputStream::set_newline_type
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "DataInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDataInputStream.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gio", name = "DataStreamNewlineType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of new line return as #GDataStreamNewlineType.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_data_input_stream_set_newline_type" g_data_input_stream_set_newline_type ::
        Ptr DataInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "DataInputStream"})
        CUInt ->                                -- type : TInterface (Name {namespace = "Gio", name = "DataStreamNewlineType"})
        IO ()

    {- |
    Sets the newline type for the /@stream@/.

    Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read
    chunk ends in \"CR\" we must read an additional byte to know if this is \"CR\" or
    \"CR LF\", and this might block if there is no more data available.
    -}
    dataInputStreamSetNewlineType ::
        (B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a) =>
        a
        {- ^ /@stream@/: a 'GI.Gio.Objects.DataInputStream.DataInputStream'. -}
        -> Gio.Enums.DataStreamNewlineType
        {- ^ /@type@/: the type of new line return as 'GI.Gio.Enums.DataStreamNewlineType'. -}
        -> m ()
    dataInputStreamSetNewlineType stream type_ = liftIO $ do
        stream' <- unsafeManagedPtrCastPtr stream
        let type_' = (fromIntegral . fromEnum) type_
        g_data_input_stream_set_newline_type stream' type_'
        touchManagedPtr stream
        return ()

    #if ENABLE_OVERLOADING
    data DataInputStreamSetNewlineTypeMethodInfo
    instance (signature ~ (Gio.Enums.DataStreamNewlineType -> m ()), MonadIO m, IsDataInputStream a) => O.MethodInfo DataInputStreamSetNewlineTypeMethodInfo a signature where
        overloadedMethod _ = dataInputStreamSetNewlineType

    #endif