{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Converter output stream implements t'GI.Gio.Objects.OutputStream.OutputStream' and allows
-- conversion of data of various types during reading.
-- 
-- As of GLib 2.34, t'GI.Gio.Objects.ConverterOutputStream.ConverterOutputStream' implements
-- t'GI.Gio.Interfaces.PollableOutputStream.PollableOutputStream'.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gio.Objects.ConverterOutputStream
    ( 

-- * Exported types
    ConverterOutputStream(..)               ,
    IsConverterOutputStream                 ,
    toConverterOutputStream                 ,
    noConverterOutputStream                 ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveConverterOutputStreamMethod      ,
#endif


-- ** getConverter #method:getConverter#

#if defined(ENABLE_OVERLOADING)
    ConverterOutputStreamGetConverterMethodInfo,
#endif
    converterOutputStreamGetConverter       ,


-- ** new #method:new#

    converterOutputStreamNew                ,




 -- * Properties
-- ** converter #attr:converter#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ConverterOutputStreamConverterPropertyInfo,
#endif
    constructConverterOutputStreamConverter ,
#if defined(ENABLE_OVERLOADING)
    converterOutputStreamConverter          ,
#endif
    getConverterOutputStreamConverter       ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Converter as Gio.Converter
import {-# SOURCE #-} qualified GI.Gio.Interfaces.PollableOutputStream as Gio.PollableOutputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.FilterOutputStream as Gio.FilterOutputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.OutputStream as Gio.OutputStream

-- | Memory-managed wrapper type.
newtype ConverterOutputStream = ConverterOutputStream (ManagedPtr ConverterOutputStream)
    deriving (ConverterOutputStream -> ConverterOutputStream -> Bool
(ConverterOutputStream -> ConverterOutputStream -> Bool)
-> (ConverterOutputStream -> ConverterOutputStream -> Bool)
-> Eq ConverterOutputStream
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConverterOutputStream -> ConverterOutputStream -> Bool
$c/= :: ConverterOutputStream -> ConverterOutputStream -> Bool
== :: ConverterOutputStream -> ConverterOutputStream -> Bool
$c== :: ConverterOutputStream -> ConverterOutputStream -> Bool
Eq)
foreign import ccall "g_converter_output_stream_get_type"
    c_g_converter_output_stream_get_type :: IO GType

instance GObject ConverterOutputStream where
    gobjectType :: IO GType
gobjectType = IO GType
c_g_converter_output_stream_get_type
    

-- | Convert 'ConverterOutputStream' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue ConverterOutputStream where
    toGValue :: ConverterOutputStream -> IO GValue
toGValue o :: ConverterOutputStream
o = do
        GType
gtype <- IO GType
c_g_converter_output_stream_get_type
        ConverterOutputStream
-> (Ptr ConverterOutputStream -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ConverterOutputStream
o (GType
-> (GValue -> Ptr ConverterOutputStream -> IO ())
-> Ptr ConverterOutputStream
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ConverterOutputStream -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO ConverterOutputStream
fromGValue gv :: GValue
gv = do
        Ptr ConverterOutputStream
ptr <- GValue -> IO (Ptr ConverterOutputStream)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr ConverterOutputStream)
        (ManagedPtr ConverterOutputStream -> ConverterOutputStream)
-> Ptr ConverterOutputStream -> IO ConverterOutputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ConverterOutputStream -> ConverterOutputStream
ConverterOutputStream Ptr ConverterOutputStream
ptr
        
    

-- | Type class for types which can be safely cast to `ConverterOutputStream`, for instance with `toConverterOutputStream`.
class (GObject o, O.IsDescendantOf ConverterOutputStream o) => IsConverterOutputStream o
instance (GObject o, O.IsDescendantOf ConverterOutputStream o) => IsConverterOutputStream o

instance O.HasParentTypes ConverterOutputStream
type instance O.ParentTypes ConverterOutputStream = '[Gio.FilterOutputStream.FilterOutputStream, Gio.OutputStream.OutputStream, GObject.Object.Object, Gio.PollableOutputStream.PollableOutputStream]

-- | Cast to `ConverterOutputStream`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toConverterOutputStream :: (MonadIO m, IsConverterOutputStream o) => o -> m ConverterOutputStream
toConverterOutputStream :: o -> m ConverterOutputStream
toConverterOutputStream = IO ConverterOutputStream -> m ConverterOutputStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ConverterOutputStream -> m ConverterOutputStream)
-> (o -> IO ConverterOutputStream) -> o -> m ConverterOutputStream
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ConverterOutputStream -> ConverterOutputStream)
-> o -> IO ConverterOutputStream
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr ConverterOutputStream -> ConverterOutputStream
ConverterOutputStream

-- | A convenience alias for `Nothing` :: `Maybe` `ConverterOutputStream`.
noConverterOutputStream :: Maybe ConverterOutputStream
noConverterOutputStream :: Maybe ConverterOutputStream
noConverterOutputStream = Maybe ConverterOutputStream
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveConverterOutputStreamMethod (t :: Symbol) (o :: *) :: * where
    ResolveConverterOutputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveConverterOutputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveConverterOutputStreamMethod "canPoll" o = Gio.PollableOutputStream.PollableOutputStreamCanPollMethodInfo
    ResolveConverterOutputStreamMethod "clearPending" o = Gio.OutputStream.OutputStreamClearPendingMethodInfo
    ResolveConverterOutputStreamMethod "close" o = Gio.OutputStream.OutputStreamCloseMethodInfo
    ResolveConverterOutputStreamMethod "closeAsync" o = Gio.OutputStream.OutputStreamCloseAsyncMethodInfo
    ResolveConverterOutputStreamMethod "closeFinish" o = Gio.OutputStream.OutputStreamCloseFinishMethodInfo
    ResolveConverterOutputStreamMethod "createSource" o = Gio.PollableOutputStream.PollableOutputStreamCreateSourceMethodInfo
    ResolveConverterOutputStreamMethod "flush" o = Gio.OutputStream.OutputStreamFlushMethodInfo
    ResolveConverterOutputStreamMethod "flushAsync" o = Gio.OutputStream.OutputStreamFlushAsyncMethodInfo
    ResolveConverterOutputStreamMethod "flushFinish" o = Gio.OutputStream.OutputStreamFlushFinishMethodInfo
    ResolveConverterOutputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveConverterOutputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveConverterOutputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveConverterOutputStreamMethod "hasPending" o = Gio.OutputStream.OutputStreamHasPendingMethodInfo
    ResolveConverterOutputStreamMethod "isClosed" o = Gio.OutputStream.OutputStreamIsClosedMethodInfo
    ResolveConverterOutputStreamMethod "isClosing" o = Gio.OutputStream.OutputStreamIsClosingMethodInfo
    ResolveConverterOutputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveConverterOutputStreamMethod "isWritable" o = Gio.PollableOutputStream.PollableOutputStreamIsWritableMethodInfo
    ResolveConverterOutputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveConverterOutputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveConverterOutputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveConverterOutputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveConverterOutputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveConverterOutputStreamMethod "splice" o = Gio.OutputStream.OutputStreamSpliceMethodInfo
    ResolveConverterOutputStreamMethod "spliceAsync" o = Gio.OutputStream.OutputStreamSpliceAsyncMethodInfo
    ResolveConverterOutputStreamMethod "spliceFinish" o = Gio.OutputStream.OutputStreamSpliceFinishMethodInfo
    ResolveConverterOutputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveConverterOutputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveConverterOutputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveConverterOutputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveConverterOutputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveConverterOutputStreamMethod "write" o = Gio.OutputStream.OutputStreamWriteMethodInfo
    ResolveConverterOutputStreamMethod "writeAll" o = Gio.OutputStream.OutputStreamWriteAllMethodInfo
    ResolveConverterOutputStreamMethod "writeAllAsync" o = Gio.OutputStream.OutputStreamWriteAllAsyncMethodInfo
    ResolveConverterOutputStreamMethod "writeAllFinish" o = Gio.OutputStream.OutputStreamWriteAllFinishMethodInfo
    ResolveConverterOutputStreamMethod "writeAsync" o = Gio.OutputStream.OutputStreamWriteAsyncMethodInfo
    ResolveConverterOutputStreamMethod "writeBytes" o = Gio.OutputStream.OutputStreamWriteBytesMethodInfo
    ResolveConverterOutputStreamMethod "writeBytesAsync" o = Gio.OutputStream.OutputStreamWriteBytesAsyncMethodInfo
    ResolveConverterOutputStreamMethod "writeBytesFinish" o = Gio.OutputStream.OutputStreamWriteBytesFinishMethodInfo
    ResolveConverterOutputStreamMethod "writeFinish" o = Gio.OutputStream.OutputStreamWriteFinishMethodInfo
    ResolveConverterOutputStreamMethod "writeNonblocking" o = Gio.PollableOutputStream.PollableOutputStreamWriteNonblockingMethodInfo
    ResolveConverterOutputStreamMethod "writev" o = Gio.OutputStream.OutputStreamWritevMethodInfo
    ResolveConverterOutputStreamMethod "writevAll" o = Gio.OutputStream.OutputStreamWritevAllMethodInfo
    ResolveConverterOutputStreamMethod "writevAllAsync" o = Gio.OutputStream.OutputStreamWritevAllAsyncMethodInfo
    ResolveConverterOutputStreamMethod "writevAllFinish" o = Gio.OutputStream.OutputStreamWritevAllFinishMethodInfo
    ResolveConverterOutputStreamMethod "writevAsync" o = Gio.OutputStream.OutputStreamWritevAsyncMethodInfo
    ResolveConverterOutputStreamMethod "writevFinish" o = Gio.OutputStream.OutputStreamWritevFinishMethodInfo
    ResolveConverterOutputStreamMethod "writevNonblocking" o = Gio.PollableOutputStream.PollableOutputStreamWritevNonblockingMethodInfo
    ResolveConverterOutputStreamMethod "getBaseStream" o = Gio.FilterOutputStream.FilterOutputStreamGetBaseStreamMethodInfo
    ResolveConverterOutputStreamMethod "getCloseBaseStream" o = Gio.FilterOutputStream.FilterOutputStreamGetCloseBaseStreamMethodInfo
    ResolveConverterOutputStreamMethod "getConverter" o = ConverterOutputStreamGetConverterMethodInfo
    ResolveConverterOutputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveConverterOutputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveConverterOutputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveConverterOutputStreamMethod "setCloseBaseStream" o = Gio.FilterOutputStream.FilterOutputStreamSetCloseBaseStreamMethodInfo
    ResolveConverterOutputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveConverterOutputStreamMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveConverterOutputStreamMethod "setPending" o = Gio.OutputStream.OutputStreamSetPendingMethodInfo
    ResolveConverterOutputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveConverterOutputStreamMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveConverterOutputStreamMethod t ConverterOutputStream, O.MethodInfo info ConverterOutputStream p) => OL.IsLabel t (ConverterOutputStream -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#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' converterOutputStream #converter
-- @
getConverterOutputStreamConverter :: (MonadIO m, IsConverterOutputStream o) => o -> m Gio.Converter.Converter
getConverterOutputStreamConverter :: o -> m Converter
getConverterOutputStreamConverter obj :: o
obj = IO Converter -> m Converter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Converter -> m Converter) -> IO Converter -> m Converter
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Converter) -> IO Converter
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "getConverterOutputStreamConverter" (IO (Maybe Converter) -> IO Converter)
-> IO (Maybe Converter) -> IO Converter
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr Converter -> Converter)
-> IO (Maybe Converter)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj "converter" ManagedPtr Converter -> 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`.
constructConverterOutputStreamConverter :: (IsConverterOutputStream o, Gio.Converter.IsConverter a) => a -> IO (GValueConstruct o)
constructConverterOutputStreamConverter :: a -> IO (GValueConstruct o)
constructConverterOutputStreamConverter val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "converter" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

#if defined(ENABLE_OVERLOADING)
data ConverterOutputStreamConverterPropertyInfo
instance AttrInfo ConverterOutputStreamConverterPropertyInfo where
    type AttrAllowedOps ConverterOutputStreamConverterPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ConverterOutputStreamConverterPropertyInfo = IsConverterOutputStream
    type AttrSetTypeConstraint ConverterOutputStreamConverterPropertyInfo = Gio.Converter.IsConverter
    type AttrTransferTypeConstraint ConverterOutputStreamConverterPropertyInfo = Gio.Converter.IsConverter
    type AttrTransferType ConverterOutputStreamConverterPropertyInfo = Gio.Converter.Converter
    type AttrGetType ConverterOutputStreamConverterPropertyInfo = Gio.Converter.Converter
    type AttrLabel ConverterOutputStreamConverterPropertyInfo = "converter"
    type AttrOrigin ConverterOutputStreamConverterPropertyInfo = ConverterOutputStream
    attrGet = getConverterOutputStreamConverter
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Gio.Converter.Converter v
    attrConstruct = constructConverterOutputStreamConverter
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ConverterOutputStream
type instance O.AttributeList ConverterOutputStream = ConverterOutputStreamAttributeList
type ConverterOutputStreamAttributeList = ('[ '("baseStream", Gio.FilterOutputStream.FilterOutputStreamBaseStreamPropertyInfo), '("closeBaseStream", Gio.FilterOutputStream.FilterOutputStreamCloseBaseStreamPropertyInfo), '("converter", ConverterOutputStreamConverterPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
converterOutputStreamConverter :: AttrLabelProxy "converter"
converterOutputStreamConverter = AttrLabelProxy

#endif

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

#endif

-- method ConverterOutputStream::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "base_stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "OutputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GOutputStream" , 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 = "ConverterOutputStream" })
-- throws : False
-- Skip return : False

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

-- | Creates a new converter output stream for the /@baseStream@/.
converterOutputStreamNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.OutputStream.IsOutputStream a, Gio.Converter.IsConverter b) =>
    a
    -- ^ /@baseStream@/: a t'GI.Gio.Objects.OutputStream.OutputStream'
    -> b
    -- ^ /@converter@/: a t'GI.Gio.Interfaces.Converter.Converter'
    -> m ConverterOutputStream
    -- ^ __Returns:__ a new t'GI.Gio.Objects.OutputStream.OutputStream'.
converterOutputStreamNew :: a -> b -> m ConverterOutputStream
converterOutputStreamNew baseStream :: a
baseStream converter :: b
converter = IO ConverterOutputStream -> m ConverterOutputStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ConverterOutputStream -> m ConverterOutputStream)
-> IO ConverterOutputStream -> m ConverterOutputStream
forall a b. (a -> b) -> a -> b
$ do
    Ptr OutputStream
baseStream' <- a -> IO (Ptr OutputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
baseStream
    Ptr Converter
converter' <- b -> IO (Ptr Converter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
converter
    Ptr ConverterOutputStream
result <- Ptr OutputStream -> Ptr Converter -> IO (Ptr ConverterOutputStream)
g_converter_output_stream_new Ptr OutputStream
baseStream' Ptr Converter
converter'
    Text -> Ptr ConverterOutputStream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "converterOutputStreamNew" Ptr ConverterOutputStream
result
    ConverterOutputStream
result' <- ((ManagedPtr ConverterOutputStream -> ConverterOutputStream)
-> Ptr ConverterOutputStream -> IO ConverterOutputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ConverterOutputStream -> ConverterOutputStream
ConverterOutputStream) Ptr ConverterOutputStream
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
baseStream
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
converter
    ConverterOutputStream -> IO ConverterOutputStream
forall (m :: * -> *) a. Monad m => a -> m a
return ConverterOutputStream
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method ConverterOutputStream::get_converter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "converter_stream"
--           , argType =
--               TInterface
--                 Name { namespace = "Gio" , name = "ConverterOutputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GConverterOutputStream"
--                 , 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_output_stream_get_converter" g_converter_output_stream_get_converter :: 
    Ptr ConverterOutputStream ->            -- converter_stream : TInterface (Name {namespace = "Gio", name = "ConverterOutputStream"})
    IO (Ptr Gio.Converter.Converter)

-- | Gets the t'GI.Gio.Interfaces.Converter.Converter' that is used by /@converterStream@/.
-- 
-- /Since: 2.24/
converterOutputStreamGetConverter ::
    (B.CallStack.HasCallStack, MonadIO m, IsConverterOutputStream a) =>
    a
    -- ^ /@converterStream@/: a t'GI.Gio.Objects.ConverterOutputStream.ConverterOutputStream'
    -> m Gio.Converter.Converter
    -- ^ __Returns:__ the converter of the converter output stream
converterOutputStreamGetConverter :: a -> m Converter
converterOutputStreamGetConverter converterStream :: a
converterStream = IO Converter -> m Converter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Converter -> m Converter) -> IO Converter -> m Converter
forall a b. (a -> b) -> a -> b
$ do
    Ptr ConverterOutputStream
converterStream' <- a -> IO (Ptr ConverterOutputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
converterStream
    Ptr Converter
result <- Ptr ConverterOutputStream -> IO (Ptr Converter)
g_converter_output_stream_get_converter Ptr ConverterOutputStream
converterStream'
    Text -> Ptr Converter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "converterOutputStreamGetConverter" Ptr Converter
result
    Converter
result' <- ((ManagedPtr Converter -> Converter)
-> Ptr Converter -> IO Converter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Converter -> Converter
Gio.Converter.Converter) Ptr Converter
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
converterStream
    Converter -> IO Converter
forall (m :: * -> *) a. Monad m => a -> m a
return Converter
result'

#if defined(ENABLE_OVERLOADING)
data ConverterOutputStreamGetConverterMethodInfo
instance (signature ~ (m Gio.Converter.Converter), MonadIO m, IsConverterOutputStream a) => O.MethodInfo ConverterOutputStreamGetConverterMethodInfo a signature where
    overloadedMethod = converterOutputStreamGetConverter

#endif