{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Structure representing an entry in the \"ostree.sizes\" commit metadata. Each
-- entry corresponds to an object in the associated commit.
-- 
-- /Since: 2020.1/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.OSTree.Structs.CommitSizesEntry
    ( 

-- * Exported types
    CommitSizesEntry(..)                    ,
    newZeroCommitSizesEntry                 ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.OSTree.Structs.CommitSizesEntry#g:method:copy"), [free]("GI.OSTree.Structs.CommitSizesEntry#g:method:free").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveCommitSizesEntryMethod           ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    CommitSizesEntryCopyMethodInfo          ,
#endif
    commitSizesEntryCopy                    ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    CommitSizesEntryFreeMethodInfo          ,
#endif
    commitSizesEntryFree                    ,


-- ** new #method:new#

    commitSizesEntryNew                     ,




 -- * Properties


-- ** archived #attr:archived#
-- | compressed object size

#if defined(ENABLE_OVERLOADING)
    commitSizesEntry_archived               ,
#endif
    getCommitSizesEntryArchived             ,
    setCommitSizesEntryArchived             ,


-- ** checksum #attr:checksum#
-- | object checksum

    clearCommitSizesEntryChecksum           ,
#if defined(ENABLE_OVERLOADING)
    commitSizesEntry_checksum               ,
#endif
    getCommitSizesEntryChecksum             ,
    setCommitSizesEntryChecksum             ,


-- ** objtype #attr:objtype#
-- | object type

#if defined(ENABLE_OVERLOADING)
    commitSizesEntry_objtype                ,
#endif
    getCommitSizesEntryObjtype              ,
    setCommitSizesEntryObjtype              ,


-- ** unpacked #attr:unpacked#
-- | unpacked object size

#if defined(ENABLE_OVERLOADING)
    commitSizesEntry_unpacked               ,
#endif
    getCommitSizesEntryUnpacked             ,
    setCommitSizesEntryUnpacked             ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums

#else
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums

#endif

-- | Memory-managed wrapper type.
newtype CommitSizesEntry = CommitSizesEntry (SP.ManagedPtr CommitSizesEntry)
    deriving (CommitSizesEntry -> CommitSizesEntry -> Bool
(CommitSizesEntry -> CommitSizesEntry -> Bool)
-> (CommitSizesEntry -> CommitSizesEntry -> Bool)
-> Eq CommitSizesEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CommitSizesEntry -> CommitSizesEntry -> Bool
== :: CommitSizesEntry -> CommitSizesEntry -> Bool
$c/= :: CommitSizesEntry -> CommitSizesEntry -> Bool
/= :: CommitSizesEntry -> CommitSizesEntry -> Bool
Eq)

instance SP.ManagedPtrNewtype CommitSizesEntry where
    toManagedPtr :: CommitSizesEntry -> ManagedPtr CommitSizesEntry
toManagedPtr (CommitSizesEntry ManagedPtr CommitSizesEntry
p) = ManagedPtr CommitSizesEntry
p

foreign import ccall "ostree_commit_sizes_entry_get_type" c_ostree_commit_sizes_entry_get_type :: 
    IO GType

type instance O.ParentTypes CommitSizesEntry = '[]
instance O.HasParentTypes CommitSizesEntry

instance B.Types.TypedObject CommitSizesEntry where
    glibType :: IO GType
glibType = IO GType
c_ostree_commit_sizes_entry_get_type

instance B.Types.GBoxed CommitSizesEntry

-- | Convert t'CommitSizesEntry' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe CommitSizesEntry) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ostree_commit_sizes_entry_get_type
    gvalueSet_ :: Ptr GValue -> Maybe CommitSizesEntry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe CommitSizesEntry
P.Nothing = Ptr GValue -> Ptr CommitSizesEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr CommitSizesEntry
forall a. Ptr a
FP.nullPtr :: FP.Ptr CommitSizesEntry)
    gvalueSet_ Ptr GValue
gv (P.Just CommitSizesEntry
obj) = CommitSizesEntry -> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CommitSizesEntry
obj (Ptr GValue -> Ptr CommitSizesEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe CommitSizesEntry)
gvalueGet_ Ptr GValue
gv = do
        ptr <- Ptr GValue -> IO (Ptr CommitSizesEntry)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr CommitSizesEntry)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newBoxed CommitSizesEntry ptr
        else return P.Nothing
        
    

-- | Construct a t'CommitSizesEntry' struct initialized to zero.
newZeroCommitSizesEntry :: MonadIO m => m CommitSizesEntry
newZeroCommitSizesEntry :: forall (m :: * -> *). MonadIO m => m CommitSizesEntry
newZeroCommitSizesEntry = IO CommitSizesEntry -> m CommitSizesEntry
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CommitSizesEntry -> m CommitSizesEntry)
-> IO CommitSizesEntry -> m CommitSizesEntry
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr CommitSizesEntry)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
24 IO (Ptr CommitSizesEntry)
-> (Ptr CommitSizesEntry -> IO CommitSizesEntry)
-> IO CommitSizesEntry
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr CommitSizesEntry -> CommitSizesEntry)
-> Ptr CommitSizesEntry -> IO CommitSizesEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CommitSizesEntry -> CommitSizesEntry
CommitSizesEntry

instance tag ~ 'AttrSet => Constructible CommitSizesEntry tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr CommitSizesEntry -> CommitSizesEntry)
-> [AttrOp CommitSizesEntry tag] -> m CommitSizesEntry
new ManagedPtr CommitSizesEntry -> CommitSizesEntry
_ [AttrOp CommitSizesEntry tag]
attrs = do
        o <- m CommitSizesEntry
forall (m :: * -> *). MonadIO m => m CommitSizesEntry
newZeroCommitSizesEntry
        GI.Attributes.set o attrs
        return o


-- | Get the value of the “@checksum@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' commitSizesEntry #checksum
-- @
getCommitSizesEntryChecksum :: MonadIO m => CommitSizesEntry -> m (Maybe T.Text)
getCommitSizesEntryChecksum :: forall (m :: * -> *).
MonadIO m =>
CommitSizesEntry -> m (Maybe Text)
getCommitSizesEntryChecksum CommitSizesEntry
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
$ CommitSizesEntry
-> (Ptr CommitSizesEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr CommitSizesEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
    result <- SP.convertIfNonNull val $ \CString
val' -> do
        val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        return val''
    return result

-- | Set the value of the “@checksum@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' commitSizesEntry [ #checksum 'Data.GI.Base.Attributes.:=' value ]
-- @
setCommitSizesEntryChecksum :: MonadIO m => CommitSizesEntry -> CString -> m ()
setCommitSizesEntryChecksum :: forall (m :: * -> *).
MonadIO m =>
CommitSizesEntry -> CString -> m ()
setCommitSizesEntryChecksum CommitSizesEntry
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
$ CommitSizesEntry -> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO ()) -> IO ())
-> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)

-- | Set the value of the “@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' #checksum
-- @
clearCommitSizesEntryChecksum :: MonadIO m => CommitSizesEntry -> m ()
clearCommitSizesEntryChecksum :: forall (m :: * -> *). MonadIO m => CommitSizesEntry -> m ()
clearCommitSizesEntryChecksum CommitSizesEntry
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
$ CommitSizesEntry -> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO ()) -> IO ())
-> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data CommitSizesEntryChecksumFieldInfo
instance AttrInfo CommitSizesEntryChecksumFieldInfo where
    type AttrBaseTypeConstraint CommitSizesEntryChecksumFieldInfo = (~) CommitSizesEntry
    type AttrAllowedOps CommitSizesEntryChecksumFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CommitSizesEntryChecksumFieldInfo = (~) CString
    type AttrTransferTypeConstraint CommitSizesEntryChecksumFieldInfo = (~)CString
    type AttrTransferType CommitSizesEntryChecksumFieldInfo = CString
    type AttrGetType CommitSizesEntryChecksumFieldInfo = Maybe T.Text
    type AttrLabel CommitSizesEntryChecksumFieldInfo = "checksum"
    type AttrOrigin CommitSizesEntryChecksumFieldInfo = CommitSizesEntry
    attrGet = getCommitSizesEntryChecksum
    attrSet = setCommitSizesEntryChecksum
    attrConstruct = undefined
    attrClear = clearCommitSizesEntryChecksum
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.CommitSizesEntry.checksum"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-CommitSizesEntry.html#g:attr:checksum"
        })

commitSizesEntry_checksum :: AttrLabelProxy "checksum"
commitSizesEntry_checksum = AttrLabelProxy

#endif


-- | Get the value of the “@objtype@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' commitSizesEntry #objtype
-- @
getCommitSizesEntryObjtype :: MonadIO m => CommitSizesEntry -> m OSTree.Enums.ObjectType
getCommitSizesEntryObjtype :: forall (m :: * -> *). MonadIO m => CommitSizesEntry -> m ObjectType
getCommitSizesEntryObjtype CommitSizesEntry
s = IO ObjectType -> m ObjectType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ObjectType -> m ObjectType) -> IO ObjectType -> m ObjectType
forall a b. (a -> b) -> a -> b
$ CommitSizesEntry
-> (Ptr CommitSizesEntry -> IO ObjectType) -> IO ObjectType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO ObjectType) -> IO ObjectType)
-> (Ptr CommitSizesEntry -> IO ObjectType) -> IO ObjectType
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CUInt
    let val' = (Int -> ObjectType
forall a. Enum a => Int -> a
toEnum (Int -> ObjectType) -> (CUInt -> Int) -> CUInt -> ObjectType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    return val'

-- | Set the value of the “@objtype@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' commitSizesEntry [ #objtype 'Data.GI.Base.Attributes.:=' value ]
-- @
setCommitSizesEntryObjtype :: MonadIO m => CommitSizesEntry -> OSTree.Enums.ObjectType -> m ()
setCommitSizesEntryObjtype :: forall (m :: * -> *).
MonadIO m =>
CommitSizesEntry -> ObjectType -> m ()
setCommitSizesEntryObjtype CommitSizesEntry
s ObjectType
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
$ CommitSizesEntry -> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO ()) -> IO ())
-> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ObjectType -> Int) -> ObjectType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectType -> Int
forall a. Enum a => a -> Int
fromEnum) ObjectType
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data CommitSizesEntryObjtypeFieldInfo
instance AttrInfo CommitSizesEntryObjtypeFieldInfo where
    type AttrBaseTypeConstraint CommitSizesEntryObjtypeFieldInfo = (~) CommitSizesEntry
    type AttrAllowedOps CommitSizesEntryObjtypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint CommitSizesEntryObjtypeFieldInfo = (~) OSTree.Enums.ObjectType
    type AttrTransferTypeConstraint CommitSizesEntryObjtypeFieldInfo = (~)OSTree.Enums.ObjectType
    type AttrTransferType CommitSizesEntryObjtypeFieldInfo = OSTree.Enums.ObjectType
    type AttrGetType CommitSizesEntryObjtypeFieldInfo = OSTree.Enums.ObjectType
    type AttrLabel CommitSizesEntryObjtypeFieldInfo = "objtype"
    type AttrOrigin CommitSizesEntryObjtypeFieldInfo = CommitSizesEntry
    attrGet = getCommitSizesEntryObjtype
    attrSet = setCommitSizesEntryObjtype
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.CommitSizesEntry.objtype"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-CommitSizesEntry.html#g:attr:objtype"
        })

commitSizesEntry_objtype :: AttrLabelProxy "objtype"
commitSizesEntry_objtype = AttrLabelProxy

#endif


-- | Get the value of the “@unpacked@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' commitSizesEntry #unpacked
-- @
getCommitSizesEntryUnpacked :: MonadIO m => CommitSizesEntry -> m Word64
getCommitSizesEntryUnpacked :: forall (m :: * -> *). MonadIO m => CommitSizesEntry -> m Word64
getCommitSizesEntryUnpacked CommitSizesEntry
s = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ CommitSizesEntry
-> (Ptr CommitSizesEntry -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO Word64) -> IO Word64)
-> (Ptr CommitSizesEntry -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word64
    return val

-- | Set the value of the “@unpacked@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' commitSizesEntry [ #unpacked 'Data.GI.Base.Attributes.:=' value ]
-- @
setCommitSizesEntryUnpacked :: MonadIO m => CommitSizesEntry -> Word64 -> m ()
setCommitSizesEntryUnpacked :: forall (m :: * -> *).
MonadIO m =>
CommitSizesEntry -> Word64 -> m ()
setCommitSizesEntryUnpacked CommitSizesEntry
s Word64
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
$ CommitSizesEntry -> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO ()) -> IO ())
-> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word64
val :: Word64)

#if defined(ENABLE_OVERLOADING)
data CommitSizesEntryUnpackedFieldInfo
instance AttrInfo CommitSizesEntryUnpackedFieldInfo where
    type AttrBaseTypeConstraint CommitSizesEntryUnpackedFieldInfo = (~) CommitSizesEntry
    type AttrAllowedOps CommitSizesEntryUnpackedFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint CommitSizesEntryUnpackedFieldInfo = (~) Word64
    type AttrTransferTypeConstraint CommitSizesEntryUnpackedFieldInfo = (~)Word64
    type AttrTransferType CommitSizesEntryUnpackedFieldInfo = Word64
    type AttrGetType CommitSizesEntryUnpackedFieldInfo = Word64
    type AttrLabel CommitSizesEntryUnpackedFieldInfo = "unpacked"
    type AttrOrigin CommitSizesEntryUnpackedFieldInfo = CommitSizesEntry
    attrGet = getCommitSizesEntryUnpacked
    attrSet = setCommitSizesEntryUnpacked
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.CommitSizesEntry.unpacked"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-CommitSizesEntry.html#g:attr:unpacked"
        })

commitSizesEntry_unpacked :: AttrLabelProxy "unpacked"
commitSizesEntry_unpacked = AttrLabelProxy

#endif


-- | Get the value of the “@archived@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' commitSizesEntry #archived
-- @
getCommitSizesEntryArchived :: MonadIO m => CommitSizesEntry -> m Word64
getCommitSizesEntryArchived :: forall (m :: * -> *). MonadIO m => CommitSizesEntry -> m Word64
getCommitSizesEntryArchived CommitSizesEntry
s = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ CommitSizesEntry
-> (Ptr CommitSizesEntry -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO Word64) -> IO Word64)
-> (Ptr CommitSizesEntry -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Word64
    return val

-- | Set the value of the “@archived@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' commitSizesEntry [ #archived 'Data.GI.Base.Attributes.:=' value ]
-- @
setCommitSizesEntryArchived :: MonadIO m => CommitSizesEntry -> Word64 -> m ()
setCommitSizesEntryArchived :: forall (m :: * -> *).
MonadIO m =>
CommitSizesEntry -> Word64 -> m ()
setCommitSizesEntryArchived CommitSizesEntry
s Word64
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
$ CommitSizesEntry -> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr CommitSizesEntry
s ((Ptr CommitSizesEntry -> IO ()) -> IO ())
-> (Ptr CommitSizesEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CommitSizesEntry
ptr Ptr CommitSizesEntry -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Word64
val :: Word64)

#if defined(ENABLE_OVERLOADING)
data CommitSizesEntryArchivedFieldInfo
instance AttrInfo CommitSizesEntryArchivedFieldInfo where
    type AttrBaseTypeConstraint CommitSizesEntryArchivedFieldInfo = (~) CommitSizesEntry
    type AttrAllowedOps CommitSizesEntryArchivedFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint CommitSizesEntryArchivedFieldInfo = (~) Word64
    type AttrTransferTypeConstraint CommitSizesEntryArchivedFieldInfo = (~)Word64
    type AttrTransferType CommitSizesEntryArchivedFieldInfo = Word64
    type AttrGetType CommitSizesEntryArchivedFieldInfo = Word64
    type AttrLabel CommitSizesEntryArchivedFieldInfo = "archived"
    type AttrOrigin CommitSizesEntryArchivedFieldInfo = CommitSizesEntry
    attrGet = getCommitSizesEntryArchived
    attrSet = setCommitSizesEntryArchived
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.CommitSizesEntry.archived"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-CommitSizesEntry.html#g:attr:archived"
        })

commitSizesEntry_archived :: AttrLabelProxy "archived"
commitSizesEntry_archived = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CommitSizesEntry
type instance O.AttributeList CommitSizesEntry = CommitSizesEntryAttributeList
type CommitSizesEntryAttributeList = ('[ '("checksum", CommitSizesEntryChecksumFieldInfo), '("objtype", CommitSizesEntryObjtypeFieldInfo), '("unpacked", CommitSizesEntryUnpackedFieldInfo), '("archived", CommitSizesEntryArchivedFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method CommitSizesEntry::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "object checksum" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , argCType = Just "OstreeObjectType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unpacked"
--           , argType = TBasicType TUInt64
--           , argCType = Just "guint64"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "unpacked object size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "archived"
--           , argType = TBasicType TUInt64
--           , argCType = Just "guint64"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "compressed object size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "OSTree" , name = "CommitSizesEntry" })
-- throws : False
-- Skip return : False

foreign import ccall "ostree_commit_sizes_entry_new" ostree_commit_sizes_entry_new :: 
    CString ->                              -- checksum : TBasicType TUTF8
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    Word64 ->                               -- unpacked : TBasicType TUInt64
    Word64 ->                               -- archived : TBasicType TUInt64
    IO (Ptr CommitSizesEntry)

-- | Create a new t'GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry' for representing an object in a
-- commit\'s \"ostree.sizes\" metadata.
-- 
-- /Since: 2020.1/
commitSizesEntryNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@checksum@/: object checksum
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: object type
    -> Word64
    -- ^ /@unpacked@/: unpacked object size
    -> Word64
    -- ^ /@archived@/: compressed object size
    -> m (Maybe CommitSizesEntry)
    -- ^ __Returns:__ a new t'GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry'
commitSizesEntryNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text
-> ObjectType -> Word64 -> Word64 -> m (Maybe CommitSizesEntry)
commitSizesEntryNew Text
checksum ObjectType
objtype Word64
unpacked Word64
archived = IO (Maybe CommitSizesEntry) -> m (Maybe CommitSizesEntry)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe CommitSizesEntry) -> m (Maybe CommitSizesEntry))
-> IO (Maybe CommitSizesEntry) -> m (Maybe CommitSizesEntry)
forall a b. (a -> b) -> a -> b
$ do
    checksum' <- Text -> IO CString
textToCString Text
checksum
    let objtype' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ObjectType -> Int) -> ObjectType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectType -> Int
forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    result <- ostree_commit_sizes_entry_new checksum' objtype' unpacked archived
    maybeResult <- convertIfNonNull result $ \Ptr CommitSizesEntry
result' -> do
        result'' <- ((ManagedPtr CommitSizesEntry -> CommitSizesEntry)
-> Ptr CommitSizesEntry -> IO CommitSizesEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CommitSizesEntry -> CommitSizesEntry
CommitSizesEntry) Ptr CommitSizesEntry
result'
        return result''
    freeMem checksum'
    return maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method CommitSizesEntry::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "CommitSizesEntry" }
--           , argCType = Just "const OstreeCommitSizesEntry*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeCommitSizesEntry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "OSTree" , name = "CommitSizesEntry" })
-- throws : False
-- Skip return : False

foreign import ccall "ostree_commit_sizes_entry_copy" ostree_commit_sizes_entry_copy :: 
    Ptr CommitSizesEntry ->                 -- entry : TInterface (Name {namespace = "OSTree", name = "CommitSizesEntry"})
    IO (Ptr CommitSizesEntry)

-- | Create a copy of the given /@entry@/.
-- 
-- /Since: 2020.1/
commitSizesEntryCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CommitSizesEntry
    -- ^ /@entry@/: an t'GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry'
    -> m (Maybe CommitSizesEntry)
    -- ^ __Returns:__ a new copy of /@entry@/
commitSizesEntryCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CommitSizesEntry -> m (Maybe CommitSizesEntry)
commitSizesEntryCopy CommitSizesEntry
entry = IO (Maybe CommitSizesEntry) -> m (Maybe CommitSizesEntry)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe CommitSizesEntry) -> m (Maybe CommitSizesEntry))
-> IO (Maybe CommitSizesEntry) -> m (Maybe CommitSizesEntry)
forall a b. (a -> b) -> a -> b
$ do
    entry' <- CommitSizesEntry -> IO (Ptr CommitSizesEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CommitSizesEntry
entry
    result <- ostree_commit_sizes_entry_copy entry'
    maybeResult <- convertIfNonNull result $ \Ptr CommitSizesEntry
result' -> do
        result'' <- ((ManagedPtr CommitSizesEntry -> CommitSizesEntry)
-> Ptr CommitSizesEntry -> IO CommitSizesEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CommitSizesEntry -> CommitSizesEntry
CommitSizesEntry) Ptr CommitSizesEntry
result'
        return result''
    touchManagedPtr entry
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data CommitSizesEntryCopyMethodInfo
instance (signature ~ (m (Maybe CommitSizesEntry)), MonadIO m) => O.OverloadedMethod CommitSizesEntryCopyMethodInfo CommitSizesEntry signature where
    overloadedMethod = commitSizesEntryCopy

instance O.OverloadedMethodInfo CommitSizesEntryCopyMethodInfo CommitSizesEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.CommitSizesEntry.commitSizesEntryCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-CommitSizesEntry.html#v:commitSizesEntryCopy"
        })


#endif

-- method CommitSizesEntry::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "CommitSizesEntry" }
--           , argCType = Just "OstreeCommitSizesEntry*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeCommitSizesEntry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_commit_sizes_entry_free" ostree_commit_sizes_entry_free :: 
    Ptr CommitSizesEntry ->                 -- entry : TInterface (Name {namespace = "OSTree", name = "CommitSizesEntry"})
    IO ()

-- | Free given /@entry@/.
-- 
-- /Since: 2020.1/
commitSizesEntryFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CommitSizesEntry
    -- ^ /@entry@/: an t'GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry'
    -> m ()
commitSizesEntryFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CommitSizesEntry -> m ()
commitSizesEntryFree CommitSizesEntry
entry = 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
    entry' <- CommitSizesEntry -> IO (Ptr CommitSizesEntry)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed CommitSizesEntry
entry
    ostree_commit_sizes_entry_free entry'
    touchManagedPtr entry
    return ()

#if defined(ENABLE_OVERLOADING)
data CommitSizesEntryFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod CommitSizesEntryFreeMethodInfo CommitSizesEntry signature where
    overloadedMethod = commitSizesEntryFree

instance O.OverloadedMethodInfo CommitSizesEntryFreeMethodInfo CommitSizesEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Structs.CommitSizesEntry.commitSizesEntryFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Structs-CommitSizesEntry.html#v:commitSizesEntryFree"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveCommitSizesEntryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveCommitSizesEntryMethod "copy" o = CommitSizesEntryCopyMethodInfo
    ResolveCommitSizesEntryMethod "free" o = CommitSizesEntryFreeMethodInfo
    ResolveCommitSizesEntryMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCommitSizesEntryMethod t CommitSizesEntry, O.OverloadedMethod info CommitSizesEntry p) => OL.IsLabel t (CommitSizesEntry -> 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 ~ ResolveCommitSizesEntryMethod t CommitSizesEntry, O.OverloadedMethod info CommitSizesEntry p, R.HasField t CommitSizesEntry p) => R.HasField t CommitSizesEntry p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveCommitSizesEntryMethod t CommitSizesEntry, O.OverloadedMethodInfo info CommitSizesEntry) => OL.IsLabel t (O.MethodProxy info CommitSizesEntry) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif