{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.OSTree.Structs.DiffItem
(
DiffItem(..) ,
newZeroDiffItem ,
#if defined(ENABLE_OVERLOADING)
ResolveDiffItemMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DiffItemRefMethodInfo ,
#endif
diffItemRef ,
#if defined(ENABLE_OVERLOADING)
DiffItemUnrefMethodInfo ,
#endif
diffItemUnref ,
#if defined(ENABLE_OVERLOADING)
diffItem_refcount ,
#endif
getDiffItemRefcount ,
setDiffItemRefcount ,
clearDiffItemSrc ,
#if defined(ENABLE_OVERLOADING)
diffItem_src ,
#endif
getDiffItemSrc ,
setDiffItemSrc ,
clearDiffItemSrcChecksum ,
#if defined(ENABLE_OVERLOADING)
diffItem_srcChecksum ,
#endif
getDiffItemSrcChecksum ,
setDiffItemSrcChecksum ,
clearDiffItemSrcInfo ,
#if defined(ENABLE_OVERLOADING)
diffItem_srcInfo ,
#endif
getDiffItemSrcInfo ,
setDiffItemSrcInfo ,
clearDiffItemTarget ,
#if defined(ENABLE_OVERLOADING)
diffItem_target ,
#endif
getDiffItemTarget ,
setDiffItemTarget ,
clearDiffItemTargetChecksum ,
#if defined(ENABLE_OVERLOADING)
diffItem_targetChecksum ,
#endif
getDiffItemTargetChecksum ,
setDiffItemTargetChecksum ,
clearDiffItemTargetInfo ,
#if defined(ENABLE_OVERLOADING)
diffItem_targetInfo ,
#endif
getDiffItemTargetInfo ,
setDiffItemTargetInfo ,
) 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.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo
newtype DiffItem = DiffItem (SP.ManagedPtr DiffItem)
deriving (DiffItem -> DiffItem -> Bool
(DiffItem -> DiffItem -> Bool)
-> (DiffItem -> DiffItem -> Bool) -> Eq DiffItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffItem -> DiffItem -> Bool
== :: DiffItem -> DiffItem -> Bool
$c/= :: DiffItem -> DiffItem -> Bool
/= :: DiffItem -> DiffItem -> Bool
Eq)
instance SP.ManagedPtrNewtype DiffItem where
toManagedPtr :: DiffItem -> ManagedPtr DiffItem
toManagedPtr (DiffItem ManagedPtr DiffItem
p) = ManagedPtr DiffItem
p
foreign import ccall "ostree_diff_item_get_type" c_ostree_diff_item_get_type ::
IO GType
type instance O.ParentTypes DiffItem = '[]
instance O.HasParentTypes DiffItem
instance B.Types.TypedObject DiffItem where
glibType :: IO GType
glibType = IO GType
c_ostree_diff_item_get_type
instance B.Types.GBoxed DiffItem
instance B.GValue.IsGValue (Maybe DiffItem) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ostree_diff_item_get_type
gvalueSet_ :: Ptr GValue -> Maybe DiffItem -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DiffItem
P.Nothing = Ptr GValue -> Ptr DiffItem -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr DiffItem
forall a. Ptr a
FP.nullPtr :: FP.Ptr DiffItem)
gvalueSet_ Ptr GValue
gv (P.Just DiffItem
obj) = DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DiffItem
obj (Ptr GValue -> Ptr DiffItem -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DiffItem)
gvalueGet_ Ptr GValue
gv = do
Ptr DiffItem
ptr <- Ptr GValue -> IO (Ptr DiffItem)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr DiffItem)
if Ptr DiffItem
ptr Ptr DiffItem -> Ptr DiffItem -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DiffItem
forall a. Ptr a
FP.nullPtr
then DiffItem -> Maybe DiffItem
forall a. a -> Maybe a
P.Just (DiffItem -> Maybe DiffItem) -> IO DiffItem -> IO (Maybe DiffItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DiffItem -> DiffItem) -> Ptr DiffItem -> IO DiffItem
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr DiffItem -> DiffItem
DiffItem Ptr DiffItem
ptr
else Maybe DiffItem -> IO (Maybe DiffItem)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DiffItem
forall a. Maybe a
P.Nothing
newZeroDiffItem :: MonadIO m => m DiffItem
newZeroDiffItem :: forall (m :: * -> *). MonadIO m => m DiffItem
newZeroDiffItem = IO DiffItem -> m DiffItem
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiffItem -> m DiffItem) -> IO DiffItem -> m DiffItem
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr DiffItem)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
56 IO (Ptr DiffItem) -> (Ptr DiffItem -> IO DiffItem) -> IO DiffItem
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr DiffItem -> DiffItem) -> Ptr DiffItem -> IO DiffItem
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DiffItem -> DiffItem
DiffItem
instance tag ~ 'AttrSet => Constructible DiffItem tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr DiffItem -> DiffItem)
-> [AttrOp DiffItem tag] -> m DiffItem
new ManagedPtr DiffItem -> DiffItem
_ [AttrOp DiffItem tag]
attrs = do
DiffItem
o <- m DiffItem
forall (m :: * -> *). MonadIO m => m DiffItem
newZeroDiffItem
DiffItem -> [AttrOp DiffItem 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set DiffItem
o [AttrOp DiffItem tag]
[AttrOp DiffItem 'AttrSet]
attrs
DiffItem -> m DiffItem
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return DiffItem
o
getDiffItemRefcount :: MonadIO m => DiffItem -> m Int32
getDiffItemRefcount :: forall (m :: * -> *). MonadIO m => DiffItem -> m Int32
getDiffItemRefcount DiffItem
s = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ DiffItem -> (Ptr DiffItem -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO Int32) -> IO Int32)
-> (Ptr DiffItem -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Int32
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDiffItemRefcount :: MonadIO m => DiffItem -> Int32 -> m ()
setDiffItemRefcount :: forall (m :: * -> *). MonadIO m => DiffItem -> Int32 -> m ()
setDiffItemRefcount DiffItem
s Int32
val = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DiffItemRefcountFieldInfo
instance AttrInfo DiffItemRefcountFieldInfo where
type AttrBaseTypeConstraint DiffItemRefcountFieldInfo = (~) DiffItem
type AttrAllowedOps DiffItemRefcountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DiffItemRefcountFieldInfo = (~) Int32
type AttrTransferTypeConstraint DiffItemRefcountFieldInfo = (~)Int32
type AttrTransferType DiffItemRefcountFieldInfo = Int32
type AttrGetType DiffItemRefcountFieldInfo = Int32
type AttrLabel DiffItemRefcountFieldInfo = "refcount"
type AttrOrigin DiffItemRefcountFieldInfo = DiffItem
attrGet = getDiffItemRefcount
attrSet = setDiffItemRefcount
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.refcount"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#g:attr:refcount"
})
diffItem_refcount :: AttrLabelProxy "refcount"
diffItem_refcount = AttrLabelProxy
#endif
getDiffItemSrc :: MonadIO m => DiffItem -> m (Maybe Gio.File.File)
getDiffItemSrc :: forall (m :: * -> *). MonadIO m => DiffItem -> m (Maybe File)
getDiffItemSrc DiffItem
s = IO (Maybe File) -> m (Maybe File)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe File) -> m (Maybe File))
-> IO (Maybe File) -> m (Maybe File)
forall a b. (a -> b) -> a -> b
$ DiffItem -> (Ptr DiffItem -> IO (Maybe File)) -> IO (Maybe File)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO (Maybe File)) -> IO (Maybe File))
-> (Ptr DiffItem -> IO (Maybe File)) -> IO (Maybe File)
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr File
val <- Ptr (Ptr File) -> IO (Ptr File)
forall a. Storable a => Ptr a -> IO a
peek (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr File)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr Gio.File.File)
Maybe File
result <- Ptr File -> (Ptr File -> IO File) -> IO (Maybe File)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr File
val ((Ptr File -> IO File) -> IO (Maybe File))
-> (Ptr File -> IO File) -> IO (Maybe File)
forall a b. (a -> b) -> a -> b
$ \Ptr File
val' -> do
File
val'' <- ((ManagedPtr File -> File) -> Ptr File -> IO File
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr File -> File
Gio.File.File) Ptr File
val'
File -> IO File
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return File
val''
Maybe File -> IO (Maybe File)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe File
result
setDiffItemSrc :: MonadIO m => DiffItem -> Ptr Gio.File.File -> m ()
setDiffItemSrc :: forall (m :: * -> *). MonadIO m => DiffItem -> Ptr File -> m ()
setDiffItemSrc DiffItem
s Ptr File
val = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr (Ptr File) -> Ptr File -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr File)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr File
val :: Ptr Gio.File.File)
clearDiffItemSrc :: MonadIO m => DiffItem -> m ()
clearDiffItemSrc :: forall (m :: * -> *). MonadIO m => DiffItem -> m ()
clearDiffItemSrc DiffItem
s = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr (Ptr File) -> Ptr File -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr File)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr File
forall a. Ptr a
FP.nullPtr :: Ptr Gio.File.File)
#if defined(ENABLE_OVERLOADING)
data DiffItemSrcFieldInfo
instance AttrInfo DiffItemSrcFieldInfo where
type AttrBaseTypeConstraint DiffItemSrcFieldInfo = (~) DiffItem
type AttrAllowedOps DiffItemSrcFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DiffItemSrcFieldInfo = (~) (Ptr Gio.File.File)
type AttrTransferTypeConstraint DiffItemSrcFieldInfo = (~)(Ptr Gio.File.File)
type AttrTransferType DiffItemSrcFieldInfo = (Ptr Gio.File.File)
type AttrGetType DiffItemSrcFieldInfo = Maybe Gio.File.File
type AttrLabel DiffItemSrcFieldInfo = "src"
type AttrOrigin DiffItemSrcFieldInfo = DiffItem
attrGet = getDiffItemSrc
attrSet = setDiffItemSrc
attrConstruct = undefined
attrClear = clearDiffItemSrc
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.src"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#g:attr:src"
})
diffItem_src :: AttrLabelProxy "src"
diffItem_src = AttrLabelProxy
#endif
getDiffItemTarget :: MonadIO m => DiffItem -> m (Maybe Gio.File.File)
getDiffItemTarget :: forall (m :: * -> *). MonadIO m => DiffItem -> m (Maybe File)
getDiffItemTarget DiffItem
s = IO (Maybe File) -> m (Maybe File)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe File) -> m (Maybe File))
-> IO (Maybe File) -> m (Maybe File)
forall a b. (a -> b) -> a -> b
$ DiffItem -> (Ptr DiffItem -> IO (Maybe File)) -> IO (Maybe File)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO (Maybe File)) -> IO (Maybe File))
-> (Ptr DiffItem -> IO (Maybe File)) -> IO (Maybe File)
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr File
val <- Ptr (Ptr File) -> IO (Ptr File)
forall a. Storable a => Ptr a -> IO a
peek (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr File)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr Gio.File.File)
Maybe File
result <- Ptr File -> (Ptr File -> IO File) -> IO (Maybe File)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr File
val ((Ptr File -> IO File) -> IO (Maybe File))
-> (Ptr File -> IO File) -> IO (Maybe File)
forall a b. (a -> b) -> a -> b
$ \Ptr File
val' -> do
File
val'' <- ((ManagedPtr File -> File) -> Ptr File -> IO File
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr File -> File
Gio.File.File) Ptr File
val'
File -> IO File
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return File
val''
Maybe File -> IO (Maybe File)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe File
result
setDiffItemTarget :: MonadIO m => DiffItem -> Ptr Gio.File.File -> m ()
setDiffItemTarget :: forall (m :: * -> *). MonadIO m => DiffItem -> Ptr File -> m ()
setDiffItemTarget DiffItem
s Ptr File
val = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr (Ptr File) -> Ptr File -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr File)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr File
val :: Ptr Gio.File.File)
clearDiffItemTarget :: MonadIO m => DiffItem -> m ()
clearDiffItemTarget :: forall (m :: * -> *). MonadIO m => DiffItem -> m ()
clearDiffItemTarget DiffItem
s = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr (Ptr File) -> Ptr File -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr File)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr File
forall a. Ptr a
FP.nullPtr :: Ptr Gio.File.File)
#if defined(ENABLE_OVERLOADING)
data DiffItemTargetFieldInfo
instance AttrInfo DiffItemTargetFieldInfo where
type AttrBaseTypeConstraint DiffItemTargetFieldInfo = (~) DiffItem
type AttrAllowedOps DiffItemTargetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DiffItemTargetFieldInfo = (~) (Ptr Gio.File.File)
type AttrTransferTypeConstraint DiffItemTargetFieldInfo = (~)(Ptr Gio.File.File)
type AttrTransferType DiffItemTargetFieldInfo = (Ptr Gio.File.File)
type AttrGetType DiffItemTargetFieldInfo = Maybe Gio.File.File
type AttrLabel DiffItemTargetFieldInfo = "target"
type AttrOrigin DiffItemTargetFieldInfo = DiffItem
attrGet = getDiffItemTarget
attrSet = setDiffItemTarget
attrConstruct = undefined
attrClear = clearDiffItemTarget
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.target"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#g:attr:target"
})
diffItem_target :: AttrLabelProxy "target"
diffItem_target = AttrLabelProxy
#endif
getDiffItemSrcInfo :: MonadIO m => DiffItem -> m (Maybe Gio.FileInfo.FileInfo)
getDiffItemSrcInfo :: forall (m :: * -> *). MonadIO m => DiffItem -> m (Maybe FileInfo)
getDiffItemSrcInfo DiffItem
s = IO (Maybe FileInfo) -> m (Maybe FileInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FileInfo) -> m (Maybe FileInfo))
-> IO (Maybe FileInfo) -> m (Maybe FileInfo)
forall a b. (a -> b) -> a -> b
$ DiffItem
-> (Ptr DiffItem -> IO (Maybe FileInfo)) -> IO (Maybe FileInfo)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO (Maybe FileInfo)) -> IO (Maybe FileInfo))
-> (Ptr DiffItem -> IO (Maybe FileInfo)) -> IO (Maybe FileInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr FileInfo
val <- Ptr (Ptr FileInfo) -> IO (Ptr FileInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr FileInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO (Ptr Gio.FileInfo.FileInfo)
Maybe FileInfo
result <- Ptr FileInfo
-> (Ptr FileInfo -> IO FileInfo) -> IO (Maybe FileInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr FileInfo
val ((Ptr FileInfo -> IO FileInfo) -> IO (Maybe FileInfo))
-> (Ptr FileInfo -> IO FileInfo) -> IO (Maybe FileInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr FileInfo
val' -> do
FileInfo
val'' <- ((ManagedPtr FileInfo -> FileInfo) -> Ptr FileInfo -> IO FileInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FileInfo -> FileInfo
Gio.FileInfo.FileInfo) Ptr FileInfo
val'
FileInfo -> IO FileInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FileInfo
val''
Maybe FileInfo -> IO (Maybe FileInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FileInfo
result
setDiffItemSrcInfo :: MonadIO m => DiffItem -> Ptr Gio.FileInfo.FileInfo -> m ()
setDiffItemSrcInfo :: forall (m :: * -> *). MonadIO m => DiffItem -> Ptr FileInfo -> m ()
setDiffItemSrcInfo DiffItem
s Ptr FileInfo
val = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr (Ptr FileInfo) -> Ptr FileInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr FileInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr FileInfo
val :: Ptr Gio.FileInfo.FileInfo)
clearDiffItemSrcInfo :: MonadIO m => DiffItem -> m ()
clearDiffItemSrcInfo :: forall (m :: * -> *). MonadIO m => DiffItem -> m ()
clearDiffItemSrcInfo DiffItem
s = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr (Ptr FileInfo) -> Ptr FileInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr FileInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr FileInfo
forall a. Ptr a
FP.nullPtr :: Ptr Gio.FileInfo.FileInfo)
#if defined(ENABLE_OVERLOADING)
data DiffItemSrcInfoFieldInfo
instance AttrInfo DiffItemSrcInfoFieldInfo where
type AttrBaseTypeConstraint DiffItemSrcInfoFieldInfo = (~) DiffItem
type AttrAllowedOps DiffItemSrcInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DiffItemSrcInfoFieldInfo = (~) (Ptr Gio.FileInfo.FileInfo)
type AttrTransferTypeConstraint DiffItemSrcInfoFieldInfo = (~)(Ptr Gio.FileInfo.FileInfo)
type AttrTransferType DiffItemSrcInfoFieldInfo = (Ptr Gio.FileInfo.FileInfo)
type AttrGetType DiffItemSrcInfoFieldInfo = Maybe Gio.FileInfo.FileInfo
type AttrLabel DiffItemSrcInfoFieldInfo = "src_info"
type AttrOrigin DiffItemSrcInfoFieldInfo = DiffItem
attrGet = getDiffItemSrcInfo
attrSet = setDiffItemSrcInfo
attrConstruct = undefined
attrClear = clearDiffItemSrcInfo
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.srcInfo"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#g:attr:srcInfo"
})
diffItem_srcInfo :: AttrLabelProxy "srcInfo"
diffItem_srcInfo = AttrLabelProxy
#endif
getDiffItemTargetInfo :: MonadIO m => DiffItem -> m (Maybe Gio.FileInfo.FileInfo)
getDiffItemTargetInfo :: forall (m :: * -> *). MonadIO m => DiffItem -> m (Maybe FileInfo)
getDiffItemTargetInfo DiffItem
s = IO (Maybe FileInfo) -> m (Maybe FileInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FileInfo) -> m (Maybe FileInfo))
-> IO (Maybe FileInfo) -> m (Maybe FileInfo)
forall a b. (a -> b) -> a -> b
$ DiffItem
-> (Ptr DiffItem -> IO (Maybe FileInfo)) -> IO (Maybe FileInfo)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO (Maybe FileInfo)) -> IO (Maybe FileInfo))
-> (Ptr DiffItem -> IO (Maybe FileInfo)) -> IO (Maybe FileInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr FileInfo
val <- Ptr (Ptr FileInfo) -> IO (Ptr FileInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr FileInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (Ptr Gio.FileInfo.FileInfo)
Maybe FileInfo
result <- Ptr FileInfo
-> (Ptr FileInfo -> IO FileInfo) -> IO (Maybe FileInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr FileInfo
val ((Ptr FileInfo -> IO FileInfo) -> IO (Maybe FileInfo))
-> (Ptr FileInfo -> IO FileInfo) -> IO (Maybe FileInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr FileInfo
val' -> do
FileInfo
val'' <- ((ManagedPtr FileInfo -> FileInfo) -> Ptr FileInfo -> IO FileInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FileInfo -> FileInfo
Gio.FileInfo.FileInfo) Ptr FileInfo
val'
FileInfo -> IO FileInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FileInfo
val''
Maybe FileInfo -> IO (Maybe FileInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FileInfo
result
setDiffItemTargetInfo :: MonadIO m => DiffItem -> Ptr Gio.FileInfo.FileInfo -> m ()
setDiffItemTargetInfo :: forall (m :: * -> *). MonadIO m => DiffItem -> Ptr FileInfo -> m ()
setDiffItemTargetInfo DiffItem
s Ptr FileInfo
val = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr (Ptr FileInfo) -> Ptr FileInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr FileInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Ptr FileInfo
val :: Ptr Gio.FileInfo.FileInfo)
clearDiffItemTargetInfo :: MonadIO m => DiffItem -> m ()
clearDiffItemTargetInfo :: forall (m :: * -> *). MonadIO m => DiffItem -> m ()
clearDiffItemTargetInfo DiffItem
s = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr (Ptr FileInfo) -> Ptr FileInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr (Ptr FileInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Ptr FileInfo
forall a. Ptr a
FP.nullPtr :: Ptr Gio.FileInfo.FileInfo)
#if defined(ENABLE_OVERLOADING)
data DiffItemTargetInfoFieldInfo
instance AttrInfo DiffItemTargetInfoFieldInfo where
type AttrBaseTypeConstraint DiffItemTargetInfoFieldInfo = (~) DiffItem
type AttrAllowedOps DiffItemTargetInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DiffItemTargetInfoFieldInfo = (~) (Ptr Gio.FileInfo.FileInfo)
type AttrTransferTypeConstraint DiffItemTargetInfoFieldInfo = (~)(Ptr Gio.FileInfo.FileInfo)
type AttrTransferType DiffItemTargetInfoFieldInfo = (Ptr Gio.FileInfo.FileInfo)
type AttrGetType DiffItemTargetInfoFieldInfo = Maybe Gio.FileInfo.FileInfo
type AttrLabel DiffItemTargetInfoFieldInfo = "target_info"
type AttrOrigin DiffItemTargetInfoFieldInfo = DiffItem
attrGet = getDiffItemTargetInfo
attrSet = setDiffItemTargetInfo
attrConstruct = undefined
attrClear = clearDiffItemTargetInfo
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.targetInfo"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#g:attr:targetInfo"
})
diffItem_targetInfo :: AttrLabelProxy "targetInfo"
diffItem_targetInfo = AttrLabelProxy
#endif
getDiffItemSrcChecksum :: MonadIO m => DiffItem -> m (Maybe T.Text)
getDiffItemSrcChecksum :: forall (m :: * -> *). MonadIO m => DiffItem -> m (Maybe Text)
getDiffItemSrcChecksum DiffItem
s = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ DiffItem -> (Ptr DiffItem -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr DiffItem -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setDiffItemSrcChecksum :: MonadIO m => DiffItem -> CString -> m ()
setDiffItemSrcChecksum :: forall (m :: * -> *). MonadIO m => DiffItem -> CString -> m ()
setDiffItemSrcChecksum DiffItem
s CString
val = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (CString
val :: CString)
clearDiffItemSrcChecksum :: MonadIO m => DiffItem -> m ()
clearDiffItemSrcChecksum :: forall (m :: * -> *). MonadIO m => DiffItem -> m ()
clearDiffItemSrcChecksum DiffItem
s = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data DiffItemSrcChecksumFieldInfo
instance AttrInfo DiffItemSrcChecksumFieldInfo where
type AttrBaseTypeConstraint DiffItemSrcChecksumFieldInfo = (~) DiffItem
type AttrAllowedOps DiffItemSrcChecksumFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DiffItemSrcChecksumFieldInfo = (~) CString
type AttrTransferTypeConstraint DiffItemSrcChecksumFieldInfo = (~)CString
type AttrTransferType DiffItemSrcChecksumFieldInfo = CString
type AttrGetType DiffItemSrcChecksumFieldInfo = Maybe T.Text
type AttrLabel DiffItemSrcChecksumFieldInfo = "src_checksum"
type AttrOrigin DiffItemSrcChecksumFieldInfo = DiffItem
attrGet = getDiffItemSrcChecksum
attrSet = setDiffItemSrcChecksum
attrConstruct = undefined
attrClear = clearDiffItemSrcChecksum
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.srcChecksum"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#g:attr:srcChecksum"
})
diffItem_srcChecksum :: AttrLabelProxy "srcChecksum"
diffItem_srcChecksum = AttrLabelProxy
#endif
getDiffItemTargetChecksum :: MonadIO m => DiffItem -> m (Maybe T.Text)
getDiffItemTargetChecksum :: forall (m :: * -> *). MonadIO m => DiffItem -> m (Maybe Text)
getDiffItemTargetChecksum DiffItem
s = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ DiffItem -> (Ptr DiffItem -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr DiffItem -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setDiffItemTargetChecksum :: MonadIO m => DiffItem -> CString -> m ()
setDiffItemTargetChecksum :: forall (m :: * -> *). MonadIO m => DiffItem -> CString -> m ()
setDiffItemTargetChecksum DiffItem
s CString
val = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (CString
val :: CString)
clearDiffItemTargetChecksum :: MonadIO m => DiffItem -> m ()
clearDiffItemTargetChecksum :: forall (m :: * -> *). MonadIO m => DiffItem -> m ()
clearDiffItemTargetChecksum DiffItem
s = 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
$ DiffItem -> (Ptr DiffItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DiffItem
s ((Ptr DiffItem -> IO ()) -> IO ())
-> (Ptr DiffItem -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DiffItem
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DiffItem
ptr Ptr DiffItem -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data DiffItemTargetChecksumFieldInfo
instance AttrInfo DiffItemTargetChecksumFieldInfo where
type AttrBaseTypeConstraint DiffItemTargetChecksumFieldInfo = (~) DiffItem
type AttrAllowedOps DiffItemTargetChecksumFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DiffItemTargetChecksumFieldInfo = (~) CString
type AttrTransferTypeConstraint DiffItemTargetChecksumFieldInfo = (~)CString
type AttrTransferType DiffItemTargetChecksumFieldInfo = CString
type AttrGetType DiffItemTargetChecksumFieldInfo = Maybe T.Text
type AttrLabel DiffItemTargetChecksumFieldInfo = "target_checksum"
type AttrOrigin DiffItemTargetChecksumFieldInfo = DiffItem
attrGet = getDiffItemTargetChecksum
attrSet = setDiffItemTargetChecksum
attrConstruct = undefined
attrClear = clearDiffItemTargetChecksum
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.targetChecksum"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#g:attr:targetChecksum"
})
diffItem_targetChecksum :: AttrLabelProxy "targetChecksum"
diffItem_targetChecksum = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DiffItem
type instance O.AttributeList DiffItem = DiffItemAttributeList
type DiffItemAttributeList = ('[ '("refcount", DiffItemRefcountFieldInfo), '("src", DiffItemSrcFieldInfo), '("target", DiffItemTargetFieldInfo), '("srcInfo", DiffItemSrcInfoFieldInfo), '("targetInfo", DiffItemTargetInfoFieldInfo), '("srcChecksum", DiffItemSrcChecksumFieldInfo), '("targetChecksum", DiffItemTargetChecksumFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ostree_diff_item_ref" ostree_diff_item_ref ::
Ptr DiffItem ->
IO (Ptr DiffItem)
diffItemRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
DiffItem
-> m DiffItem
diffItemRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DiffItem -> m DiffItem
diffItemRef DiffItem
diffitem = IO DiffItem -> m DiffItem
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiffItem -> m DiffItem) -> IO DiffItem -> m DiffItem
forall a b. (a -> b) -> a -> b
$ do
Ptr DiffItem
diffitem' <- DiffItem -> IO (Ptr DiffItem)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffItem
diffitem
Ptr DiffItem
result <- Ptr DiffItem -> IO (Ptr DiffItem)
ostree_diff_item_ref Ptr DiffItem
diffitem'
Text -> Ptr DiffItem -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"diffItemRef" Ptr DiffItem
result
DiffItem
result' <- ((ManagedPtr DiffItem -> DiffItem) -> Ptr DiffItem -> IO DiffItem
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DiffItem -> DiffItem
DiffItem) Ptr DiffItem
result
DiffItem -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffItem
diffitem
DiffItem -> IO DiffItem
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DiffItem
result'
#if defined(ENABLE_OVERLOADING)
data DiffItemRefMethodInfo
instance (signature ~ (m DiffItem), MonadIO m) => O.OverloadedMethod DiffItemRefMethodInfo DiffItem signature where
overloadedMethod = diffItemRef
instance O.OverloadedMethodInfo DiffItemRefMethodInfo DiffItem where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.diffItemRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#v:diffItemRef"
})
#endif
foreign import ccall "ostree_diff_item_unref" ostree_diff_item_unref ::
Ptr DiffItem ->
IO ()
diffItemUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
DiffItem
-> m ()
diffItemUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => DiffItem -> m ()
diffItemUnref DiffItem
diffitem = 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 DiffItem
diffitem' <- DiffItem -> IO (Ptr DiffItem)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DiffItem
diffitem
Ptr DiffItem -> IO ()
ostree_diff_item_unref Ptr DiffItem
diffitem'
DiffItem -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DiffItem
diffitem
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiffItemUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DiffItemUnrefMethodInfo DiffItem signature where
overloadedMethod = diffItemUnref
instance O.OverloadedMethodInfo DiffItemUnrefMethodInfo DiffItem where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.OSTree.Structs.DiffItem.diffItemUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Structs-DiffItem.html#v:diffItemUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveDiffItemMethod (t :: Symbol) (o :: *) :: * where
ResolveDiffItemMethod "ref" o = DiffItemRefMethodInfo
ResolveDiffItemMethod "unref" o = DiffItemUnrefMethodInfo
ResolveDiffItemMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDiffItemMethod t DiffItem, O.OverloadedMethod info DiffItem p) => OL.IsLabel t (DiffItem -> 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 ~ ResolveDiffItemMethod t DiffItem, O.OverloadedMethod info DiffItem p, R.HasField t DiffItem p) => R.HasField t DiffItem p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDiffItemMethod t DiffItem, O.OverloadedMethodInfo info DiffItem) => OL.IsLabel t (O.MethodProxy info DiffItem) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif