{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Objects.ChecksumInputStream
(
ChecksumInputStream(..) ,
IsChecksumInputStream ,
toChecksumInputStream ,
#if defined(ENABLE_OVERLOADING)
ResolveChecksumInputStreamMethod ,
#endif
checksumInputStreamNew ,
#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
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
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]
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
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
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"
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
foreign import ccall "ostree_checksum_input_stream_new" ostree_checksum_input_stream_new ::
Ptr Gio.InputStream.InputStream ->
Ptr GLib.Checksum.Checksum ->
IO (Ptr ChecksumInputStream)
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