{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.Checksum
(
Checksum(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveChecksumMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ChecksumCopyMethodInfo ,
#endif
checksumCopy ,
#if defined(ENABLE_OVERLOADING)
ChecksumFreeMethodInfo ,
#endif
checksumFree ,
#if defined(ENABLE_OVERLOADING)
ChecksumGetStringMethodInfo ,
#endif
checksumGetString ,
checksumNew ,
#if defined(ENABLE_OVERLOADING)
ChecksumResetMethodInfo ,
#endif
checksumReset ,
checksumTypeGetLength ,
#if defined(ENABLE_OVERLOADING)
ChecksumUpdateMethodInfo ,
#endif
checksumUpdate ,
) 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.Kind as DK
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 {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
newtype Checksum = Checksum (SP.ManagedPtr Checksum)
deriving (Checksum -> Checksum -> Bool
(Checksum -> Checksum -> Bool)
-> (Checksum -> Checksum -> Bool) -> Eq Checksum
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Checksum -> Checksum -> Bool
== :: Checksum -> Checksum -> Bool
$c/= :: Checksum -> Checksum -> Bool
/= :: Checksum -> Checksum -> Bool
Eq)
instance SP.ManagedPtrNewtype Checksum where
toManagedPtr :: Checksum -> ManagedPtr Checksum
toManagedPtr (Checksum ManagedPtr Checksum
p) = ManagedPtr Checksum
p
foreign import ccall "g_checksum_get_type" c_g_checksum_get_type ::
IO GType
type instance O.ParentTypes Checksum = '[]
instance O.HasParentTypes Checksum
instance B.Types.TypedObject Checksum where
glibType :: IO GType
glibType = IO GType
c_g_checksum_get_type
instance B.Types.GBoxed Checksum
instance B.GValue.IsGValue (Maybe Checksum) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_checksum_get_type
gvalueSet_ :: Ptr GValue -> Maybe Checksum -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Checksum
P.Nothing = Ptr GValue -> Ptr Checksum -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Checksum
forall a. Ptr a
FP.nullPtr :: FP.Ptr Checksum)
gvalueSet_ Ptr GValue
gv (P.Just Checksum
obj) = Checksum -> (Ptr Checksum -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Checksum
obj (Ptr GValue -> Ptr Checksum -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Checksum)
gvalueGet_ Ptr GValue
gv = do
Ptr Checksum
ptr <- Ptr GValue -> IO (Ptr Checksum)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Checksum)
if Ptr Checksum
ptr Ptr Checksum -> Ptr Checksum -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Checksum
forall a. Ptr a
FP.nullPtr
then Checksum -> Maybe Checksum
forall a. a -> Maybe a
P.Just (Checksum -> Maybe Checksum) -> IO Checksum -> IO (Maybe Checksum)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Checksum -> Checksum) -> Ptr Checksum -> IO Checksum
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Checksum -> Checksum
Checksum Ptr Checksum
ptr
else Maybe Checksum -> IO (Maybe Checksum)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Checksum
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Checksum
type instance O.AttributeList Checksum = ChecksumAttributeList
type ChecksumAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_checksum_new" g_checksum_new ::
CUInt ->
IO (Ptr Checksum)
checksumNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.Enums.ChecksumType
-> m (Maybe Checksum)
checksumNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ChecksumType -> m (Maybe Checksum)
checksumNew ChecksumType
checksumType = IO (Maybe Checksum) -> m (Maybe Checksum)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Checksum) -> m (Maybe Checksum))
-> IO (Maybe Checksum) -> m (Maybe Checksum)
forall a b. (a -> b) -> a -> b
$ do
let checksumType' :: CUInt
checksumType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ChecksumType -> Int) -> ChecksumType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChecksumType -> Int
forall a. Enum a => a -> Int
fromEnum) ChecksumType
checksumType
Ptr Checksum
result <- CUInt -> IO (Ptr Checksum)
g_checksum_new CUInt
checksumType'
Maybe Checksum
maybeResult <- Ptr Checksum
-> (Ptr Checksum -> IO Checksum) -> IO (Maybe Checksum)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Checksum
result ((Ptr Checksum -> IO Checksum) -> IO (Maybe Checksum))
-> (Ptr Checksum -> IO Checksum) -> IO (Maybe Checksum)
forall a b. (a -> b) -> a -> b
$ \Ptr Checksum
result' -> do
Checksum
result'' <- ((ManagedPtr Checksum -> Checksum) -> Ptr Checksum -> IO Checksum
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Checksum -> Checksum
Checksum) Ptr Checksum
result'
Checksum -> IO Checksum
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Checksum
result''
Maybe Checksum -> IO (Maybe Checksum)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Checksum
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_checksum_copy" g_checksum_copy ::
Ptr Checksum ->
IO (Ptr Checksum)
checksumCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Checksum
-> m Checksum
checksumCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Checksum -> m Checksum
checksumCopy Checksum
checksum = IO Checksum -> m Checksum
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Checksum -> m Checksum) -> IO Checksum -> m Checksum
forall a b. (a -> b) -> a -> b
$ do
Ptr Checksum
checksum' <- Checksum -> IO (Ptr Checksum)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Checksum
checksum
Ptr Checksum
result <- Ptr Checksum -> IO (Ptr Checksum)
g_checksum_copy Ptr Checksum
checksum'
Text -> Ptr Checksum -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumCopy" Ptr Checksum
result
Checksum
result' <- ((ManagedPtr Checksum -> Checksum) -> Ptr Checksum -> IO Checksum
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Checksum -> Checksum
Checksum) Ptr Checksum
result
Checksum -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Checksum
checksum
Checksum -> IO Checksum
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Checksum
result'
#if defined(ENABLE_OVERLOADING)
data ChecksumCopyMethodInfo
instance (signature ~ (m Checksum), MonadIO m) => O.OverloadedMethod ChecksumCopyMethodInfo Checksum signature where
overloadedMethod = checksumCopy
instance O.OverloadedMethodInfo ChecksumCopyMethodInfo Checksum where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Checksum.checksumCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.29/docs/GI-GLib-Structs-Checksum.html#v:checksumCopy"
})
#endif
foreign import ccall "g_checksum_free" g_checksum_free ::
Ptr Checksum ->
IO ()
checksumFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Checksum
-> m ()
checksumFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Checksum -> m ()
checksumFree Checksum
checksum = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Checksum
checksum' <- Checksum -> IO (Ptr Checksum)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Checksum
checksum
Ptr Checksum -> IO ()
g_checksum_free Ptr Checksum
checksum'
Checksum -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Checksum
checksum
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ChecksumFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ChecksumFreeMethodInfo Checksum signature where
overloadedMethod = checksumFree
instance O.OverloadedMethodInfo ChecksumFreeMethodInfo Checksum where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Checksum.checksumFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.29/docs/GI-GLib-Structs-Checksum.html#v:checksumFree"
})
#endif
foreign import ccall "g_checksum_get_string" g_checksum_get_string ::
Ptr Checksum ->
IO CString
checksumGetString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Checksum
-> m T.Text
checksumGetString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Checksum -> m Text
checksumGetString Checksum
checksum = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Checksum
checksum' <- Checksum -> IO (Ptr Checksum)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Checksum
checksum
CString
result <- Ptr Checksum -> IO CString
g_checksum_get_string Ptr Checksum
checksum'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"checksumGetString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Checksum -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Checksum
checksum
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ChecksumGetStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod ChecksumGetStringMethodInfo Checksum signature where
overloadedMethod = checksumGetString
instance O.OverloadedMethodInfo ChecksumGetStringMethodInfo Checksum where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Checksum.checksumGetString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.29/docs/GI-GLib-Structs-Checksum.html#v:checksumGetString"
})
#endif
foreign import ccall "g_checksum_reset" g_checksum_reset ::
Ptr Checksum ->
IO ()
checksumReset ::
(B.CallStack.HasCallStack, MonadIO m) =>
Checksum
-> m ()
checksumReset :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Checksum -> m ()
checksumReset Checksum
checksum = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Checksum
checksum' <- Checksum -> IO (Ptr Checksum)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Checksum
checksum
Ptr Checksum -> IO ()
g_checksum_reset Ptr Checksum
checksum'
Checksum -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Checksum
checksum
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ChecksumResetMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ChecksumResetMethodInfo Checksum signature where
overloadedMethod = checksumReset
instance O.OverloadedMethodInfo ChecksumResetMethodInfo Checksum where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Checksum.checksumReset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.29/docs/GI-GLib-Structs-Checksum.html#v:checksumReset"
})
#endif
foreign import ccall "g_checksum_update" g_checksum_update ::
Ptr Checksum ->
Ptr Word8 ->
Int64 ->
IO ()
checksumUpdate ::
(B.CallStack.HasCallStack, MonadIO m) =>
Checksum
-> ByteString
-> m ()
checksumUpdate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Checksum -> ByteString -> m ()
checksumUpdate Checksum
checksum ByteString
data_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let length_ :: Int64
length_ = Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int64) -> Int -> Int64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
data_
Ptr Checksum
checksum' <- Checksum -> IO (Ptr Checksum)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Checksum
checksum
Ptr Word8
data_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
data_
Ptr Checksum -> Ptr Word8 -> Int64 -> IO ()
g_checksum_update Ptr Checksum
checksum' Ptr Word8
data_' Int64
length_
Checksum -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Checksum
checksum
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
data_'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ChecksumUpdateMethodInfo
instance (signature ~ (ByteString -> m ()), MonadIO m) => O.OverloadedMethod ChecksumUpdateMethodInfo Checksum signature where
overloadedMethod = checksumUpdate
instance O.OverloadedMethodInfo ChecksumUpdateMethodInfo Checksum where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Checksum.checksumUpdate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.29/docs/GI-GLib-Structs-Checksum.html#v:checksumUpdate"
})
#endif
foreign import ccall "g_checksum_type_get_length" g_checksum_type_get_length ::
CUInt ->
IO Int64
checksumTypeGetLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.Enums.ChecksumType
-> m Int64
checksumTypeGetLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ChecksumType -> m Int64
checksumTypeGetLength ChecksumType
checksumType = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
let checksumType' :: CUInt
checksumType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ChecksumType -> Int) -> ChecksumType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChecksumType -> Int
forall a. Enum a => a -> Int
fromEnum) ChecksumType
checksumType
Int64
result <- CUInt -> IO Int64
g_checksum_type_get_length CUInt
checksumType'
Int64 -> IO Int64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveChecksumMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveChecksumMethod "copy" o = ChecksumCopyMethodInfo
ResolveChecksumMethod "free" o = ChecksumFreeMethodInfo
ResolveChecksumMethod "reset" o = ChecksumResetMethodInfo
ResolveChecksumMethod "update" o = ChecksumUpdateMethodInfo
ResolveChecksumMethod "getString" o = ChecksumGetStringMethodInfo
ResolveChecksumMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveChecksumMethod t Checksum, O.OverloadedMethod info Checksum p) => OL.IsLabel t (Checksum -> 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 ~ ResolveChecksumMethod t Checksum, O.OverloadedMethod info Checksum p, R.HasField t Checksum p) => R.HasField t Checksum p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveChecksumMethod t Checksum, O.OverloadedMethodInfo info Checksum) => OL.IsLabel t (O.MethodProxy info Checksum) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif