{-# 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.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
(ChecksumInputStream -> ChecksumInputStream -> Bool)
-> (ChecksumInputStream -> ChecksumInputStream -> Bool)
-> Eq ChecksumInputStream
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 = IO ChecksumInputStream -> m ChecksumInputStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ChecksumInputStream -> m ChecksumInputStream)
-> (o -> IO ChecksumInputStream) -> o -> m ChecksumInputStream
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ChecksumInputStream -> ChecksumInputStream)
-> o -> IO ChecksumInputStream
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 = Ptr GValue -> Ptr ChecksumInputStream -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ChecksumInputStream
forall a. Ptr a
FP.nullPtr :: FP.Ptr ChecksumInputStream)
    gvalueSet_ Ptr GValue
gv (P.Just ChecksumInputStream
obj) = ChecksumInputStream -> (Ptr ChecksumInputStream -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ChecksumInputStream
obj (Ptr GValue -> Ptr ChecksumInputStream -> IO ()
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 <- Ptr GValue -> IO (Ptr ChecksumInputStream)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ChecksumInputStream)
        if Ptr ChecksumInputStream
ptr Ptr ChecksumInputStream -> Ptr ChecksumInputStream -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ChecksumInputStream
forall a. Ptr a
FP.nullPtr
        then ChecksumInputStream -> Maybe ChecksumInputStream
forall a. a -> Maybe a
P.Just (ChecksumInputStream -> Maybe ChecksumInputStream)
-> IO ChecksumInputStream -> IO (Maybe ChecksumInputStream)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ChecksumInputStream -> ChecksumInputStream)
-> Ptr ChecksumInputStream -> IO ChecksumInputStream
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 Maybe ChecksumInputStream -> IO (Maybe ChecksumInputStream)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ChecksumInputStream
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 = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Ptr ())
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Ptr () -> IO (GValueConstruct o)
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.15/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 = IO ChecksumInputStream -> m ChecksumInputStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ChecksumInputStream -> m ChecksumInputStream)
-> IO ChecksumInputStream -> m ChecksumInputStream
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputStream
stream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
    Ptr Checksum
checksum' <- Checksum -> IO (Ptr 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'
    Text -> Ptr ChecksumInputStream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumInputStreamNew" Ptr ChecksumInputStream
result
    ChecksumInputStream
result' <- ((ManagedPtr ChecksumInputStream -> ChecksumInputStream)
-> Ptr ChecksumInputStream -> IO ChecksumInputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ChecksumInputStream -> ChecksumInputStream
ChecksumInputStream) Ptr ChecksumInputStream
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
    Checksum -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Checksum
checksum
    ChecksumInputStream -> IO ChecksumInputStream
forall (m :: * -> *) a. Monad m => a -> m a
return ChecksumInputStream
result'

#if defined(ENABLE_OVERLOADING)
#endif