{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.OSTree.Objects.ChecksumInputStream
    ( 

-- * Exported types
    ChecksumInputStream(..)                 ,
    IsChecksumInputStream                   ,
    toChecksumInputStream                   ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clearPending]("GI.Gio.Objects.InputStream#g:method:clearPending"), [close]("GI.Gio.Objects.InputStream#g:method:close"), [closeAsync]("GI.Gio.Objects.InputStream#g:method:closeAsync"), [closeFinish]("GI.Gio.Objects.InputStream#g:method:closeFinish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasPending]("GI.Gio.Objects.InputStream#g:method:hasPending"), [isClosed]("GI.Gio.Objects.InputStream#g:method:isClosed"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [read]("GI.Gio.Objects.InputStream#g:method:read"), [readAll]("GI.Gio.Objects.InputStream#g:method:readAll"), [readAllAsync]("GI.Gio.Objects.InputStream#g:method:readAllAsync"), [readAllFinish]("GI.Gio.Objects.InputStream#g:method:readAllFinish"), [readAsync]("GI.Gio.Objects.InputStream#g:method:readAsync"), [readBytes]("GI.Gio.Objects.InputStream#g:method:readBytes"), [readBytesAsync]("GI.Gio.Objects.InputStream#g:method:readBytesAsync"), [readBytesFinish]("GI.Gio.Objects.InputStream#g:method:readBytesFinish"), [readFinish]("GI.Gio.Objects.InputStream#g:method:readFinish"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [skip]("GI.Gio.Objects.InputStream#g:method:skip"), [skipAsync]("GI.Gio.Objects.InputStream#g:method:skipAsync"), [skipFinish]("GI.Gio.Objects.InputStream#g:method:skipFinish"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBaseStream]("GI.Gio.Objects.FilterInputStream#g:method:getBaseStream"), [getCloseBaseStream]("GI.Gio.Objects.FilterInputStream#g:method:getCloseBaseStream"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setCloseBaseStream]("GI.Gio.Objects.FilterInputStream#g:method:setCloseBaseStream"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setPending]("GI.Gio.Objects.InputStream#g:method:setPending"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveChecksumInputStreamMethod        ,
#endif

-- ** new #method:new#

    checksumInputStreamNew                  ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    ChecksumInputStreamChecksumPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
    checksumInputStreamChecksum             ,
#endif
    constructChecksumInputStreamChecksum    ,
    getChecksumInputStreamChecksum          ,




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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 Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R

import qualified GI.GLib.Structs.Checksum as GLib.Checksum
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Objects.FilterInputStream as Gio.FilterInputStream
import qualified GI.Gio.Objects.InputStream as Gio.InputStream

-- | Memory-managed wrapper type.
newtype ChecksumInputStream = ChecksumInputStream (SP.ManagedPtr ChecksumInputStream)
    deriving (ChecksumInputStream -> ChecksumInputStream -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChecksumInputStream -> ChecksumInputStream -> Bool
$c/= :: ChecksumInputStream -> ChecksumInputStream -> Bool
== :: ChecksumInputStream -> ChecksumInputStream -> Bool
$c== :: ChecksumInputStream -> ChecksumInputStream -> Bool
Eq)

instance SP.ManagedPtrNewtype ChecksumInputStream where
    toManagedPtr :: ChecksumInputStream -> ManagedPtr ChecksumInputStream
toManagedPtr (ChecksumInputStream ManagedPtr ChecksumInputStream
p) = ManagedPtr ChecksumInputStream
p

foreign import ccall "ostree_checksum_input_stream_get_type"
    c_ostree_checksum_input_stream_get_type :: IO B.Types.GType

instance B.Types.TypedObject ChecksumInputStream where
    glibType :: IO GType
glibType = IO GType
c_ostree_checksum_input_stream_get_type

instance B.Types.GObject ChecksumInputStream

-- | Type class for types which can be safely cast to `ChecksumInputStream`, for instance with `toChecksumInputStream`.
class (SP.GObject o, O.IsDescendantOf ChecksumInputStream o) => IsChecksumInputStream o
instance (SP.GObject o, O.IsDescendantOf ChecksumInputStream o) => IsChecksumInputStream o

instance O.HasParentTypes ChecksumInputStream
type instance O.ParentTypes ChecksumInputStream = '[Gio.FilterInputStream.FilterInputStream, Gio.InputStream.InputStream, GObject.Object.Object]

-- | Cast to `ChecksumInputStream`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toChecksumInputStream :: (MIO.MonadIO m, IsChecksumInputStream o) => o -> m ChecksumInputStream
toChecksumInputStream :: forall (m :: * -> *) o.
(MonadIO m, IsChecksumInputStream o) =>
o -> m ChecksumInputStream
toChecksumInputStream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ChecksumInputStream -> ChecksumInputStream
ChecksumInputStream

-- | Convert 'ChecksumInputStream' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe ChecksumInputStream) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ostree_checksum_input_stream_get_type
    gvalueSet_ :: Ptr GValue -> Maybe ChecksumInputStream -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ChecksumInputStream
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr ChecksumInputStream)
    gvalueSet_ Ptr GValue
gv (P.Just ChecksumInputStream
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ChecksumInputStream
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe ChecksumInputStream)
gvalueGet_ Ptr GValue
gv = do
        Ptr ChecksumInputStream
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ChecksumInputStream)
        if Ptr ChecksumInputStream
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
        then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ChecksumInputStream -> ChecksumInputStream
ChecksumInputStream Ptr ChecksumInputStream
ptr
        else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
        
    

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

instance (info ~ ResolveChecksumInputStreamMethod t ChecksumInputStream, O.OverloadedMethod info ChecksumInputStream p) => OL.IsLabel t (ChecksumInputStream -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveChecksumInputStreamMethod t ChecksumInputStream, O.OverloadedMethod info ChecksumInputStream p, R.HasField t ChecksumInputStream p) => R.HasField t ChecksumInputStream p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveChecksumInputStreamMethod t ChecksumInputStream, O.OverloadedMethodInfo info ChecksumInputStream) => OL.IsLabel t (O.MethodProxy info ChecksumInputStream) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "checksum"
   -- Type: TBasicType TPtr
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@checksum@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' checksumInputStream #checksum
-- @
getChecksumInputStreamChecksum :: (MonadIO m, IsChecksumInputStream o) => o -> m (Ptr ())
getChecksumInputStreamChecksum :: forall (m :: * -> *) o.
(MonadIO m, IsChecksumInputStream o) =>
o -> m (Ptr ())
getChecksumInputStreamChecksum o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b. GObject a => a -> String -> IO (Ptr b)
B.Properties.getObjectPropertyPtr o
obj String
"checksum"

-- | Construct a `GValueConstruct` with valid value for the “@checksum@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructChecksumInputStreamChecksum :: (IsChecksumInputStream o, MIO.MonadIO m) => Ptr () -> m (GValueConstruct o)
constructChecksumInputStreamChecksum :: forall o (m :: * -> *).
(IsChecksumInputStream o, MonadIO m) =>
Ptr () -> m (GValueConstruct o)
constructChecksumInputStreamChecksum Ptr ()
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall b o. String -> Ptr b -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyPtr String
"checksum" Ptr ()
val

#if defined(ENABLE_OVERLOADING)
data ChecksumInputStreamChecksumPropertyInfo
instance AttrInfo ChecksumInputStreamChecksumPropertyInfo where
    type AttrAllowedOps ChecksumInputStreamChecksumPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ChecksumInputStreamChecksumPropertyInfo = IsChecksumInputStream
    type AttrSetTypeConstraint ChecksumInputStreamChecksumPropertyInfo = (~) (Ptr ())
    type AttrTransferTypeConstraint ChecksumInputStreamChecksumPropertyInfo = (~) (Ptr ())
    type AttrTransferType ChecksumInputStreamChecksumPropertyInfo = Ptr ()
    type AttrGetType ChecksumInputStreamChecksumPropertyInfo = (Ptr ())
    type AttrLabel ChecksumInputStreamChecksumPropertyInfo = "checksum"
    type AttrOrigin ChecksumInputStreamChecksumPropertyInfo = ChecksumInputStream
    attrGet = getChecksumInputStreamChecksum
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructChecksumInputStreamChecksum
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.ChecksumInputStream.checksum"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-ChecksumInputStream.html#g:attr:checksum"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ChecksumInputStream
type instance O.AttributeList ChecksumInputStream = ChecksumInputStreamAttributeList
type ChecksumInputStreamAttributeList = ('[ '("baseStream", Gio.FilterInputStream.FilterInputStreamBaseStreamPropertyInfo), '("checksum", ChecksumInputStreamChecksumPropertyInfo), '("closeBaseStream", Gio.FilterInputStream.FilterInputStreamCloseBaseStreamPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
checksumInputStreamChecksum :: AttrLabelProxy "checksum"
checksumInputStreamChecksum = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "ostree_checksum_input_stream_new" ostree_checksum_input_stream_new :: 
    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Ptr GLib.Checksum.Checksum ->           -- checksum : TInterface (Name {namespace = "GLib", name = "Checksum"})
    IO (Ptr ChecksumInputStream)

-- | /No description available in the introspection data./
checksumInputStreamNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a) =>
    a
    -> GLib.Checksum.Checksum
    -> m ChecksumInputStream
checksumInputStreamNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputStream a) =>
a -> Checksum -> m ChecksumInputStream
checksumInputStreamNew a
stream Checksum
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    Ptr Checksum
checksum' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Checksum
checksum
    Ptr ChecksumInputStream
result <- Ptr InputStream -> Ptr Checksum -> IO (Ptr ChecksumInputStream)
ostree_checksum_input_stream_new Ptr InputStream
stream' Ptr Checksum
checksum'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumInputStreamNew" Ptr ChecksumInputStream
result
    ChecksumInputStream
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ChecksumInputStream -> ChecksumInputStream
ChecksumInputStream) Ptr ChecksumInputStream
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Checksum
checksum
    forall (m :: * -> *) a. Monad m => a -> m a
return ChecksumInputStream
result'

#if defined(ENABLE_OVERLOADING)
#endif