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

    Converter input stream implements 'GI.Gio.Objects.InputStream.InputStream' and allows
    conversion of data of various types during reading.

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

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.ConverterInputStream
        (

    -- * Exported types
        ConverterInputStream(..)                ,
        IsConverterInputStream                  ,
        toConverterInputStream                  ,
        noConverterInputStream                  ,

     -- * Methods
    -- ** getConverter #method:getConverter#

    #if ENABLE_OVERLOADING
        ConverterInputStreamGetConverterMethodInfo,
    #endif
        converterInputStreamGetConverter        ,

    -- ** new #method:new#

        converterInputStreamNew                 ,

     -- * Properties
    -- ** converter #attr:converter#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        ConverterInputStreamConverterPropertyInfo,
    #endif
        constructConverterInputStreamConverter  ,
    #if ENABLE_OVERLOADING
        converterInputStreamConverter           ,
    #endif
        getConverterInputStreamConverter        ,

        ) 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 {-# SOURCE #-} qualified GI.Gio.Interfaces.Converter as Gio.Converter
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.PollableInputStream as Gio.PollableInputStream
    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 ConverterInputStream = ConverterInputStream (ManagedPtr ConverterInputStream)
    foreign import ccall "g_converter_input_stream_get_type"
        c_g_converter_input_stream_get_type :: IO GType

    instance GObject ConverterInputStream where
        gobjectType _ = c_g_converter_input_stream_get_type

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

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

    -- | A convenience alias for `Nothing` :: `Maybe` `ConverterInputStream`.
    noConverterInputStream :: Maybe ConverterInputStream
    noConverterInputStream = Nothing

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

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveConverterInputStreamMethod t ConverterInputStream, O.MethodInfo info ConverterInputStream p) => O.IsLabel t (ConverterInputStream -> 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 "converter"
       -- Type: TInterface (Name {namespace = "Gio", name = "Converter"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' converterInputStream #converter
    @
    -}
    getConverterInputStreamConverter :: (MonadIO m, IsConverterInputStream o) => o -> m Gio.Converter.Converter
    getConverterInputStreamConverter obj = liftIO $ checkUnexpectedNothing "getConverterInputStreamConverter" $ getObjectPropertyObject obj "converter" Gio.Converter.Converter

    {- |
    Construct a `GValueConstruct` with valid value for the “@converter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructConverterInputStreamConverter :: (IsConverterInputStream o, Gio.Converter.IsConverter a) => a -> IO (GValueConstruct o)
    constructConverterInputStreamConverter val = constructObjectPropertyObject "converter" (Just val)

    #if ENABLE_OVERLOADING
    data ConverterInputStreamConverterPropertyInfo
    instance AttrInfo ConverterInputStreamConverterPropertyInfo where
        type AttrAllowedOps ConverterInputStreamConverterPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ConverterInputStreamConverterPropertyInfo = Gio.Converter.IsConverter
        type AttrBaseTypeConstraint ConverterInputStreamConverterPropertyInfo = IsConverterInputStream
        type AttrGetType ConverterInputStreamConverterPropertyInfo = Gio.Converter.Converter
        type AttrLabel ConverterInputStreamConverterPropertyInfo = "converter"
        type AttrOrigin ConverterInputStreamConverterPropertyInfo = ConverterInputStream
        attrGet _ = getConverterInputStreamConverter
        attrSet _ = undefined
        attrConstruct _ = constructConverterInputStreamConverter
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList ConverterInputStream
    type instance O.AttributeList ConverterInputStream = ConverterInputStreamAttributeList
    type ConverterInputStreamAttributeList = ('[ '("baseStream", Gio.FilterInputStream.FilterInputStreamBaseStreamPropertyInfo), '("closeBaseStream", Gio.FilterInputStream.FilterInputStreamCloseBaseStreamPropertyInfo), '("converter", ConverterInputStreamConverterPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    converterInputStreamConverter :: AttrLabelProxy "converter"
    converterInputStreamConverter = AttrLabelProxy

    #endif

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

    #endif

    -- method ConverterInputStream::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},Arg {argCName = "converter", argType = TInterface (Name {namespace = "Gio", name = "Converter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GConverter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "ConverterInputStream"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_converter_input_stream_new" g_converter_input_stream_new ::
        Ptr Gio.InputStream.InputStream ->      -- base_stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
        Ptr Gio.Converter.Converter ->          -- converter : TInterface (Name {namespace = "Gio", name = "Converter"})
        IO (Ptr ConverterInputStream)

    {- |
    Creates a new converter input stream for the /@baseStream@/.
    -}
    converterInputStreamNew ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Converter.IsConverter b) =>
        a
        {- ^ /@baseStream@/: a 'GI.Gio.Objects.InputStream.InputStream' -}
        -> b
        {- ^ /@converter@/: a 'GI.Gio.Interfaces.Converter.Converter' -}
        -> m ConverterInputStream
        {- ^ __Returns:__ a new 'GI.Gio.Objects.InputStream.InputStream'. -}
    converterInputStreamNew baseStream converter = liftIO $ do
        baseStream' <- unsafeManagedPtrCastPtr baseStream
        converter' <- unsafeManagedPtrCastPtr converter
        result <- g_converter_input_stream_new baseStream' converter'
        checkUnexpectedReturnNULL "converterInputStreamNew" result
        result' <- (wrapObject ConverterInputStream) result
        touchManagedPtr baseStream
        touchManagedPtr converter
        return result'

    #if ENABLE_OVERLOADING
    #endif

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

    foreign import ccall "g_converter_input_stream_get_converter" g_converter_input_stream_get_converter ::
        Ptr ConverterInputStream ->             -- converter_stream : TInterface (Name {namespace = "Gio", name = "ConverterInputStream"})
        IO (Ptr Gio.Converter.Converter)

    {- |
    Gets the 'GI.Gio.Interfaces.Converter.Converter' that is used by /@converterStream@/.

    /Since: 2.24/
    -}
    converterInputStreamGetConverter ::
        (B.CallStack.HasCallStack, MonadIO m, IsConverterInputStream a) =>
        a
        {- ^ /@converterStream@/: a 'GI.Gio.Objects.ConverterInputStream.ConverterInputStream' -}
        -> m Gio.Converter.Converter
        {- ^ __Returns:__ the converter of the converter input stream -}
    converterInputStreamGetConverter converterStream = liftIO $ do
        converterStream' <- unsafeManagedPtrCastPtr converterStream
        result <- g_converter_input_stream_get_converter converterStream'
        checkUnexpectedReturnNULL "converterInputStreamGetConverter" result
        result' <- (newObject Gio.Converter.Converter) result
        touchManagedPtr converterStream
        return result'

    #if ENABLE_OVERLOADING
    data ConverterInputStreamGetConverterMethodInfo
    instance (signature ~ (m Gio.Converter.Converter), MonadIO m, IsConverterInputStream a) => O.MethodInfo ConverterInputStreamGetConverterMethodInfo a signature where
        overloadedMethod _ = converterInputStreamGetConverter

    #endif