{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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.Structs.DiffItem
    ( 

-- * Exported types
    DiffItem(..)                            ,
    newZeroDiffItem                         ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveDiffItemMethod                   ,
#endif


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    DiffItemRefMethodInfo                   ,
#endif
    diffItemRef                             ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    DiffItemUnrefMethodInfo                 ,
#endif
    diffItemUnref                           ,




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

#if defined(ENABLE_OVERLOADING)
    diffItem_refcount                       ,
#endif
    getDiffItemRefcount                     ,
    setDiffItemRefcount                     ,


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

    clearDiffItemSrc                        ,
#if defined(ENABLE_OVERLOADING)
    diffItem_src                            ,
#endif
    getDiffItemSrc                          ,
    setDiffItemSrc                          ,


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

    clearDiffItemSrcChecksum                ,
#if defined(ENABLE_OVERLOADING)
    diffItem_srcChecksum                    ,
#endif
    getDiffItemSrcChecksum                  ,
    setDiffItemSrcChecksum                  ,


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

    clearDiffItemSrcInfo                    ,
#if defined(ENABLE_OVERLOADING)
    diffItem_srcInfo                        ,
#endif
    getDiffItemSrcInfo                      ,
    setDiffItemSrcInfo                      ,


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

    clearDiffItemTarget                     ,
#if defined(ENABLE_OVERLOADING)
    diffItem_target                         ,
#endif
    getDiffItemTarget                       ,
    setDiffItemTarget                       ,


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

    clearDiffItemTargetChecksum             ,
#if defined(ENABLE_OVERLOADING)
    diffItem_targetChecksum                 ,
#endif
    getDiffItemTargetChecksum               ,
    setDiffItemTargetChecksum               ,


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

    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.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.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 GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo

-- | Memory-managed wrapper type.
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
/= :: DiffItem -> DiffItem -> Bool
$c/= :: DiffItem -> DiffItem -> Bool
== :: DiffItem -> DiffItem -> Bool
$c== :: 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

-- | Convert 'DiffItem' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue DiffItem where
    toGValue :: DiffItem -> IO GValue
toGValue DiffItem
o = do
        GType
gtype <- IO GType
c_ostree_diff_item_get_type
        DiffItem -> (Ptr DiffItem -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DiffItem
o (GType
-> (GValue -> Ptr DiffItem -> IO ()) -> Ptr DiffItem -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr DiffItem -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO DiffItem
fromGValue GValue
gv = do
        Ptr DiffItem
ptr <- GValue -> IO (Ptr DiffItem)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr DiffItem)
        (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
        
    

-- | Construct a `DiffItem` struct initialized to zero.
newZeroDiffItem :: MonadIO m => m DiffItem
newZeroDiffItem :: m DiffItem
newZeroDiffItem = IO DiffItem -> m DiffItem
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 (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 :: (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 (m :: * -> *) a. Monad m => a -> m a
return DiffItem
o


-- | Get the value of the “@refcount@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' diffItem #refcount
-- @
getDiffItemRefcount :: MonadIO m => DiffItem -> m Int32
getDiffItemRefcount :: DiffItem -> m Int32
getDiffItemRefcount DiffItem
s = IO Int32 -> m Int32
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 (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@refcount@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' diffItem [ #refcount 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiffItemRefcount :: MonadIO m => DiffItem -> Int32 -> m ()
setDiffItemRefcount :: DiffItem -> Int32 -> m ()
setDiffItemRefcount DiffItem
s Int32
val = IO () -> m ()
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

diffItem_refcount :: AttrLabelProxy "refcount"
diffItem_refcount = AttrLabelProxy

#endif


-- | Get the value of the “@src@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' diffItem #src
-- @
getDiffItemSrc :: MonadIO m => DiffItem -> m (Maybe Gio.File.File)
getDiffItemSrc :: DiffItem -> m (Maybe File)
getDiffItemSrc DiffItem
s = IO (Maybe File) -> m (Maybe File)
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 (m :: * -> *) a. Monad m => a -> m a
return File
val''
    Maybe File -> IO (Maybe File)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe File
result

-- | Set the value of the “@src@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' diffItem [ #src 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiffItemSrc :: MonadIO m => DiffItem -> Ptr Gio.File.File -> m ()
setDiffItemSrc :: DiffItem -> Ptr File -> m ()
setDiffItemSrc DiffItem
s Ptr File
val = IO () -> m ()
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)

-- | Set the value of the “@src@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #src
-- @
clearDiffItemSrc :: MonadIO m => DiffItem -> m ()
clearDiffItemSrc :: DiffItem -> m ()
clearDiffItemSrc DiffItem
s = IO () -> m ()
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

diffItem_src :: AttrLabelProxy "src"
diffItem_src = AttrLabelProxy

#endif


-- | Get the value of the “@target@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' diffItem #target
-- @
getDiffItemTarget :: MonadIO m => DiffItem -> m (Maybe Gio.File.File)
getDiffItemTarget :: DiffItem -> m (Maybe File)
getDiffItemTarget DiffItem
s = IO (Maybe File) -> m (Maybe File)
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 (m :: * -> *) a. Monad m => a -> m a
return File
val''
    Maybe File -> IO (Maybe File)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe File
result

-- | Set the value of the “@target@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' diffItem [ #target 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiffItemTarget :: MonadIO m => DiffItem -> Ptr Gio.File.File -> m ()
setDiffItemTarget :: DiffItem -> Ptr File -> m ()
setDiffItemTarget DiffItem
s Ptr File
val = IO () -> m ()
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)

-- | Set the value of the “@target@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #target
-- @
clearDiffItemTarget :: MonadIO m => DiffItem -> m ()
clearDiffItemTarget :: DiffItem -> m ()
clearDiffItemTarget DiffItem
s = IO () -> m ()
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

diffItem_target :: AttrLabelProxy "target"
diffItem_target = AttrLabelProxy

#endif


-- | Get the value of the “@src_info@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' diffItem #srcInfo
-- @
getDiffItemSrcInfo :: MonadIO m => DiffItem -> m (Maybe Gio.FileInfo.FileInfo)
getDiffItemSrcInfo :: DiffItem -> m (Maybe FileInfo)
getDiffItemSrcInfo DiffItem
s = IO (Maybe FileInfo) -> m (Maybe FileInfo)
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 (m :: * -> *) a. Monad m => a -> m a
return FileInfo
val''
    Maybe FileInfo -> IO (Maybe FileInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FileInfo
result

-- | Set the value of the “@src_info@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' diffItem [ #srcInfo 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiffItemSrcInfo :: MonadIO m => DiffItem -> Ptr Gio.FileInfo.FileInfo -> m ()
setDiffItemSrcInfo :: DiffItem -> Ptr FileInfo -> m ()
setDiffItemSrcInfo DiffItem
s Ptr FileInfo
val = IO () -> m ()
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)

-- | Set the value of the “@src_info@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #srcInfo
-- @
clearDiffItemSrcInfo :: MonadIO m => DiffItem -> m ()
clearDiffItemSrcInfo :: DiffItem -> m ()
clearDiffItemSrcInfo DiffItem
s = IO () -> m ()
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

diffItem_srcInfo :: AttrLabelProxy "srcInfo"
diffItem_srcInfo = AttrLabelProxy

#endif


-- | Get the value of the “@target_info@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' diffItem #targetInfo
-- @
getDiffItemTargetInfo :: MonadIO m => DiffItem -> m (Maybe Gio.FileInfo.FileInfo)
getDiffItemTargetInfo :: DiffItem -> m (Maybe FileInfo)
getDiffItemTargetInfo DiffItem
s = IO (Maybe FileInfo) -> m (Maybe FileInfo)
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 (m :: * -> *) a. Monad m => a -> m a
return FileInfo
val''
    Maybe FileInfo -> IO (Maybe FileInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FileInfo
result

-- | Set the value of the “@target_info@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' diffItem [ #targetInfo 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiffItemTargetInfo :: MonadIO m => DiffItem -> Ptr Gio.FileInfo.FileInfo -> m ()
setDiffItemTargetInfo :: DiffItem -> Ptr FileInfo -> m ()
setDiffItemTargetInfo DiffItem
s Ptr FileInfo
val = IO () -> m ()
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)

-- | Set the value of the “@target_info@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #targetInfo
-- @
clearDiffItemTargetInfo :: MonadIO m => DiffItem -> m ()
clearDiffItemTargetInfo :: DiffItem -> m ()
clearDiffItemTargetInfo DiffItem
s = IO () -> m ()
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

diffItem_targetInfo :: AttrLabelProxy "targetInfo"
diffItem_targetInfo = AttrLabelProxy

#endif


-- | Get the value of the “@src_checksum@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' diffItem #srcChecksum
-- @
getDiffItemSrcChecksum :: MonadIO m => DiffItem -> m (Maybe T.Text)
getDiffItemSrcChecksum :: DiffItem -> m (Maybe Text)
getDiffItemSrcChecksum DiffItem
s = IO (Maybe Text) -> m (Maybe Text)
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 (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

-- | Set the value of the “@src_checksum@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' diffItem [ #srcChecksum 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiffItemSrcChecksum :: MonadIO m => DiffItem -> CString -> m ()
setDiffItemSrcChecksum :: DiffItem -> CString -> m ()
setDiffItemSrcChecksum DiffItem
s CString
val = IO () -> m ()
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)

-- | Set the value of the “@src_checksum@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #srcChecksum
-- @
clearDiffItemSrcChecksum :: MonadIO m => DiffItem -> m ()
clearDiffItemSrcChecksum :: DiffItem -> m ()
clearDiffItemSrcChecksum DiffItem
s = IO () -> m ()
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

diffItem_srcChecksum :: AttrLabelProxy "srcChecksum"
diffItem_srcChecksum = AttrLabelProxy

#endif


-- | Get the value of the “@target_checksum@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' diffItem #targetChecksum
-- @
getDiffItemTargetChecksum :: MonadIO m => DiffItem -> m (Maybe T.Text)
getDiffItemTargetChecksum :: DiffItem -> m (Maybe Text)
getDiffItemTargetChecksum DiffItem
s = IO (Maybe Text) -> m (Maybe Text)
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 (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

-- | Set the value of the “@target_checksum@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' diffItem [ #targetChecksum 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiffItemTargetChecksum :: MonadIO m => DiffItem -> CString -> m ()
setDiffItemTargetChecksum :: DiffItem -> CString -> m ()
setDiffItemTargetChecksum DiffItem
s CString
val = IO () -> m ()
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)

-- | Set the value of the “@target_checksum@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #targetChecksum
-- @
clearDiffItemTargetChecksum :: MonadIO m => DiffItem -> m ()
clearDiffItemTargetChecksum :: DiffItem -> m ()
clearDiffItemTargetChecksum DiffItem
s = IO () -> m ()
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

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

-- method DiffItem::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "diffitem"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "DiffItem" }
--           , 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 = "DiffItem" })
-- throws : False
-- Skip return : False

foreign import ccall "ostree_diff_item_ref" ostree_diff_item_ref :: 
    Ptr DiffItem ->                         -- diffitem : TInterface (Name {namespace = "OSTree", name = "DiffItem"})
    IO (Ptr DiffItem)

-- | /No description available in the introspection data./
diffItemRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DiffItem
    -> m DiffItem
diffItemRef :: DiffItem -> m DiffItem
diffItemRef DiffItem
diffitem = IO DiffItem -> m DiffItem
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 (m :: * -> *) a. Monad m => a -> m a
return DiffItem
result'

#if defined(ENABLE_OVERLOADING)
data DiffItemRefMethodInfo
instance (signature ~ (m DiffItem), MonadIO m) => O.MethodInfo DiffItemRefMethodInfo DiffItem signature where
    overloadedMethod = diffItemRef

#endif

-- method DiffItem::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "diffitem"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "DiffItem" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_diff_item_unref" ostree_diff_item_unref :: 
    Ptr DiffItem ->                         -- diffitem : TInterface (Name {namespace = "OSTree", name = "DiffItem"})
    IO ()

-- | /No description available in the introspection data./
diffItemUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DiffItem
    -> m ()
diffItemUnref :: DiffItem -> m ()
diffItemUnref DiffItem
diffitem = IO () -> m ()
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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DiffItemUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffItemUnrefMethodInfo DiffItem signature where
    overloadedMethod = 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.MethodInfo 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

#endif