{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.OSTree.Structs.DiffItem
    ( 

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


 -- * Methods
-- ** ref #method:ref#
    DiffItemRefMethodInfo                   ,
    diffItemRef                             ,


-- ** unref #method:unref#
    DiffItemUnrefMethodInfo                 ,
    diffItemUnref                           ,




 -- * Properties
-- ** refcount #attr:refcount#
    diffItem_refcount                       ,
    getDiffItemRefcount                     ,
    setDiffItemRefcount                     ,


-- ** src #attr:src#
    clearDiffItemSrc                        ,
    diffItem_src                            ,
    getDiffItemSrc                          ,
    setDiffItemSrc                          ,


-- ** srcChecksum #attr:srcChecksum#
    clearDiffItemSrcChecksum                ,
    diffItem_srcChecksum                    ,
    getDiffItemSrcChecksum                  ,
    setDiffItemSrcChecksum                  ,


-- ** srcInfo #attr:srcInfo#
    clearDiffItemSrcInfo                    ,
    diffItem_srcInfo                        ,
    getDiffItemSrcInfo                      ,
    setDiffItemSrcInfo                      ,


-- ** target #attr:target#
    clearDiffItemTarget                     ,
    diffItem_target                         ,
    getDiffItemTarget                       ,
    setDiffItemTarget                       ,


-- ** targetChecksum #attr:targetChecksum#
    clearDiffItemTargetChecksum             ,
    diffItem_targetChecksum                 ,
    getDiffItemTargetChecksum               ,
    setDiffItemTargetChecksum               ,


-- ** targetInfo #attr:targetInfo#
    clearDiffItemTargetInfo                 ,
    diffItem_targetInfo                     ,
    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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo

newtype DiffItem = DiffItem (ManagedPtr DiffItem)
foreign import ccall "ostree_diff_item_get_type" c_ostree_diff_item_get_type :: 
    IO GType

instance BoxedObject DiffItem where
    boxedType _ = c_ostree_diff_item_get_type

-- | Construct a `DiffItem` struct initialized to zero.
newZeroDiffItem :: MonadIO m => m DiffItem
newZeroDiffItem = liftIO $ callocBoxedBytes 56 >>= wrapBoxed DiffItem

instance tag ~ 'AttrSet => Constructible DiffItem tag where
    new _ attrs = do
        o <- newZeroDiffItem
        GI.Attributes.set o attrs
        return o


noDiffItem :: Maybe DiffItem
noDiffItem = Nothing

getDiffItemRefcount :: MonadIO m => DiffItem -> m Int32
getDiffItemRefcount s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return val

setDiffItemRefcount :: MonadIO m => DiffItem -> Int32 -> m ()
setDiffItemRefcount s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int32)

data DiffItemRefcountFieldInfo
instance AttrInfo DiffItemRefcountFieldInfo where
    type AttrAllowedOps DiffItemRefcountFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint DiffItemRefcountFieldInfo = (~) Int32
    type AttrBaseTypeConstraint DiffItemRefcountFieldInfo = (~) DiffItem
    type AttrGetType DiffItemRefcountFieldInfo = Int32
    type AttrLabel DiffItemRefcountFieldInfo = "refcount"
    type AttrOrigin DiffItemRefcountFieldInfo = DiffItem
    attrGet _ = getDiffItemRefcount
    attrSet _ = setDiffItemRefcount
    attrConstruct = undefined
    attrClear _ = undefined

diffItem_refcount :: AttrLabelProxy "refcount"
diffItem_refcount = AttrLabelProxy


getDiffItemSrc :: MonadIO m => DiffItem -> m (Maybe Gio.File.File)
getDiffItemSrc s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gio.File.File)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Gio.File.File) val'
        return val''
    return result

setDiffItemSrc :: MonadIO m => DiffItem -> Ptr Gio.File.File -> m ()
setDiffItemSrc s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Ptr Gio.File.File)

clearDiffItemSrc :: MonadIO m => DiffItem -> m ()
clearDiffItemSrc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gio.File.File)

data DiffItemSrcFieldInfo
instance AttrInfo DiffItemSrcFieldInfo where
    type AttrAllowedOps DiffItemSrcFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffItemSrcFieldInfo = (~) (Ptr Gio.File.File)
    type AttrBaseTypeConstraint DiffItemSrcFieldInfo = (~) DiffItem
    type AttrGetType DiffItemSrcFieldInfo = Maybe Gio.File.File
    type AttrLabel DiffItemSrcFieldInfo = "src"
    type AttrOrigin DiffItemSrcFieldInfo = DiffItem
    attrGet _ = getDiffItemSrc
    attrSet _ = setDiffItemSrc
    attrConstruct = undefined
    attrClear _ = clearDiffItemSrc

diffItem_src :: AttrLabelProxy "src"
diffItem_src = AttrLabelProxy


getDiffItemTarget :: MonadIO m => DiffItem -> m (Maybe Gio.File.File)
getDiffItemTarget s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Gio.File.File)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Gio.File.File) val'
        return val''
    return result

setDiffItemTarget :: MonadIO m => DiffItem -> Ptr Gio.File.File -> m ()
setDiffItemTarget s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Ptr Gio.File.File)

clearDiffItemTarget :: MonadIO m => DiffItem -> m ()
clearDiffItemTarget s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Gio.File.File)

data DiffItemTargetFieldInfo
instance AttrInfo DiffItemTargetFieldInfo where
    type AttrAllowedOps DiffItemTargetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffItemTargetFieldInfo = (~) (Ptr Gio.File.File)
    type AttrBaseTypeConstraint DiffItemTargetFieldInfo = (~) DiffItem
    type AttrGetType DiffItemTargetFieldInfo = Maybe Gio.File.File
    type AttrLabel DiffItemTargetFieldInfo = "target"
    type AttrOrigin DiffItemTargetFieldInfo = DiffItem
    attrGet _ = getDiffItemTarget
    attrSet _ = setDiffItemTarget
    attrConstruct = undefined
    attrClear _ = clearDiffItemTarget

diffItem_target :: AttrLabelProxy "target"
diffItem_target = AttrLabelProxy


getDiffItemSrcInfo :: MonadIO m => DiffItem -> m (Maybe Gio.FileInfo.FileInfo)
getDiffItemSrcInfo s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO (Ptr Gio.FileInfo.FileInfo)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Gio.FileInfo.FileInfo) val'
        return val''
    return result

setDiffItemSrcInfo :: MonadIO m => DiffItem -> Ptr Gio.FileInfo.FileInfo -> m ()
setDiffItemSrcInfo s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Ptr Gio.FileInfo.FileInfo)

clearDiffItemSrcInfo :: MonadIO m => DiffItem -> m ()
clearDiffItemSrcInfo s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr Gio.FileInfo.FileInfo)

data DiffItemSrcInfoFieldInfo
instance AttrInfo DiffItemSrcInfoFieldInfo where
    type AttrAllowedOps DiffItemSrcInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffItemSrcInfoFieldInfo = (~) (Ptr Gio.FileInfo.FileInfo)
    type AttrBaseTypeConstraint DiffItemSrcInfoFieldInfo = (~) DiffItem
    type AttrGetType DiffItemSrcInfoFieldInfo = Maybe Gio.FileInfo.FileInfo
    type AttrLabel DiffItemSrcInfoFieldInfo = "src_info"
    type AttrOrigin DiffItemSrcInfoFieldInfo = DiffItem
    attrGet _ = getDiffItemSrcInfo
    attrSet _ = setDiffItemSrcInfo
    attrConstruct = undefined
    attrClear _ = clearDiffItemSrcInfo

diffItem_srcInfo :: AttrLabelProxy "srcInfo"
diffItem_srcInfo = AttrLabelProxy


getDiffItemTargetInfo :: MonadIO m => DiffItem -> m (Maybe Gio.FileInfo.FileInfo)
getDiffItemTargetInfo s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO (Ptr Gio.FileInfo.FileInfo)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Gio.FileInfo.FileInfo) val'
        return val''
    return result

setDiffItemTargetInfo :: MonadIO m => DiffItem -> Ptr Gio.FileInfo.FileInfo -> m ()
setDiffItemTargetInfo s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Ptr Gio.FileInfo.FileInfo)

clearDiffItemTargetInfo :: MonadIO m => DiffItem -> m ()
clearDiffItemTargetInfo s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Gio.FileInfo.FileInfo)

data DiffItemTargetInfoFieldInfo
instance AttrInfo DiffItemTargetInfoFieldInfo where
    type AttrAllowedOps DiffItemTargetInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffItemTargetInfoFieldInfo = (~) (Ptr Gio.FileInfo.FileInfo)
    type AttrBaseTypeConstraint DiffItemTargetInfoFieldInfo = (~) DiffItem
    type AttrGetType DiffItemTargetInfoFieldInfo = Maybe Gio.FileInfo.FileInfo
    type AttrLabel DiffItemTargetInfoFieldInfo = "target_info"
    type AttrOrigin DiffItemTargetInfoFieldInfo = DiffItem
    attrGet _ = getDiffItemTargetInfo
    attrSet _ = setDiffItemTargetInfo
    attrConstruct = undefined
    attrClear _ = clearDiffItemTargetInfo

diffItem_targetInfo :: AttrLabelProxy "targetInfo"
diffItem_targetInfo = AttrLabelProxy


getDiffItemSrcChecksum :: MonadIO m => DiffItem -> m (Maybe T.Text)
getDiffItemSrcChecksum s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setDiffItemSrcChecksum :: MonadIO m => DiffItem -> CString -> m ()
setDiffItemSrcChecksum s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (val :: CString)

clearDiffItemSrcChecksum :: MonadIO m => DiffItem -> m ()
clearDiffItemSrcChecksum s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (FP.nullPtr :: CString)

data DiffItemSrcChecksumFieldInfo
instance AttrInfo DiffItemSrcChecksumFieldInfo where
    type AttrAllowedOps DiffItemSrcChecksumFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffItemSrcChecksumFieldInfo = (~) CString
    type AttrBaseTypeConstraint DiffItemSrcChecksumFieldInfo = (~) DiffItem
    type AttrGetType DiffItemSrcChecksumFieldInfo = Maybe T.Text
    type AttrLabel DiffItemSrcChecksumFieldInfo = "src_checksum"
    type AttrOrigin DiffItemSrcChecksumFieldInfo = DiffItem
    attrGet _ = getDiffItemSrcChecksum
    attrSet _ = setDiffItemSrcChecksum
    attrConstruct = undefined
    attrClear _ = clearDiffItemSrcChecksum

diffItem_srcChecksum :: AttrLabelProxy "srcChecksum"
diffItem_srcChecksum = AttrLabelProxy


getDiffItemTargetChecksum :: MonadIO m => DiffItem -> m (Maybe T.Text)
getDiffItemTargetChecksum s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setDiffItemTargetChecksum :: MonadIO m => DiffItem -> CString -> m ()
setDiffItemTargetChecksum s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (val :: CString)

clearDiffItemTargetChecksum :: MonadIO m => DiffItem -> m ()
clearDiffItemTargetChecksum s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (FP.nullPtr :: CString)

data DiffItemTargetChecksumFieldInfo
instance AttrInfo DiffItemTargetChecksumFieldInfo where
    type AttrAllowedOps DiffItemTargetChecksumFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DiffItemTargetChecksumFieldInfo = (~) CString
    type AttrBaseTypeConstraint DiffItemTargetChecksumFieldInfo = (~) DiffItem
    type AttrGetType DiffItemTargetChecksumFieldInfo = Maybe T.Text
    type AttrLabel DiffItemTargetChecksumFieldInfo = "target_checksum"
    type AttrOrigin DiffItemTargetChecksumFieldInfo = DiffItem
    attrGet _ = getDiffItemTargetChecksum
    attrSet _ = setDiffItemTargetChecksum
    attrConstruct = undefined
    attrClear _ = clearDiffItemTargetChecksum

diffItem_targetChecksum :: AttrLabelProxy "targetChecksum"
diffItem_targetChecksum = AttrLabelProxy



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, *)])

-- 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 = liftIO $ do
    diffitem' <- unsafeManagedPtrGetPtr diffitem
    result <- ostree_diff_item_ref diffitem'
    checkUnexpectedReturnNULL "diffItemRef" result
    result' <- (wrapBoxed DiffItem) result
    touchManagedPtr diffitem
    return result'

data DiffItemRefMethodInfo
instance (signature ~ (m DiffItem), MonadIO m) => O.MethodInfo DiffItemRefMethodInfo DiffItem signature where
    overloadedMethod _ = diffItemRef

-- 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 = liftIO $ do
    diffitem' <- unsafeManagedPtrGetPtr diffitem
    ostree_diff_item_unref diffitem'
    touchManagedPtr diffitem
    return ()

data DiffItemUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DiffItemUnrefMethodInfo DiffItem signature where
    overloadedMethod _ = diffItemUnref

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) => O.IsLabelProxy t (DiffItem -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDiffItemMethod t DiffItem, O.MethodInfo info DiffItem p) => O.IsLabel t (DiffItem -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif