{-# 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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

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

-- | 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
/= :: CommitSizesEntry -> CommitSizesEntry -> Bool
$c/= :: CommitSizesEntry -> CommitSizesEntry -> Bool
== :: CommitSizesEntry -> CommitSizesEntry -> Bool
$c== :: 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 '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 CommitSizesEntry
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 CommitSizesEntry
ptr Ptr CommitSizesEntry -> Ptr CommitSizesEntry -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr CommitSizesEntry
forall a. Ptr a
FP.nullPtr
        then CommitSizesEntry -> Maybe CommitSizesEntry
forall a. a -> Maybe a
P.Just (CommitSizesEntry -> Maybe CommitSizesEntry)
-> IO CommitSizesEntry -> IO (Maybe CommitSizesEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr CommitSizesEntry -> CommitSizesEntry)
-> Ptr CommitSizesEntry -> IO CommitSizesEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr CommitSizesEntry -> CommitSizesEntry
CommitSizesEntry Ptr CommitSizesEntry
ptr
        else Maybe CommitSizesEntry -> IO (Maybe CommitSizesEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CommitSizesEntry
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `CommitSizesEntry` struct initialized to zero.
newZeroCommitSizesEntry :: MonadIO m => m CommitSizesEntry
newZeroCommitSizesEntry :: forall (m :: * -> *). MonadIO m => m CommitSizesEntry
newZeroCommitSizesEntry = IO CommitSizesEntry -> m CommitSizesEntry
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
32 IO (Ptr CommitSizesEntry)
-> (Ptr CommitSizesEntry -> IO CommitSizesEntry)
-> IO CommitSizesEntry
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
        CommitSizesEntry
o <- m CommitSizesEntry
forall (m :: * -> *). MonadIO m => m CommitSizesEntry
newZeroCommitSizesEntry
        CommitSizesEntry -> [AttrOp CommitSizesEntry 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set CommitSizesEntry
o [AttrOp CommitSizesEntry tag]
[AttrOp CommitSizesEntry 'AttrSet]
attrs
        CommitSizesEntry -> m CommitSizesEntry
forall (m :: * -> *) a. Monad m => a -> m a
return CommitSizesEntry
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 (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
    CString
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
    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 “@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 (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 (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.15/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 (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
    CUInt
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
8) :: IO CUInt
    let val' :: ObjectType
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
    ObjectType -> IO ObjectType
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectType
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 (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
8) (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.15/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 (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
    Word64
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
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
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 (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 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.15/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 (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
    Word64
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
24) :: IO Word64
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
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 (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
24) (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.15/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, *)])
#endif

-- method CommitSizesEntry::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "object checksum" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unpacked"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "unpacked object size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "archived"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "compressed object size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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 (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
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    let objtype' :: CUInt
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
    Ptr CommitSizesEntry
result <- CString -> CUInt -> Word64 -> Word64 -> IO (Ptr CommitSizesEntry)
ostree_commit_sizes_entry_new CString
checksum' CUInt
objtype' Word64
unpacked Word64
archived
    Maybe CommitSizesEntry
maybeResult <- Ptr CommitSizesEntry
-> (Ptr CommitSizesEntry -> IO CommitSizesEntry)
-> IO (Maybe CommitSizesEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CommitSizesEntry
result ((Ptr CommitSizesEntry -> IO CommitSizesEntry)
 -> IO (Maybe CommitSizesEntry))
-> (Ptr CommitSizesEntry -> IO CommitSizesEntry)
-> IO (Maybe CommitSizesEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
result' -> do
        CommitSizesEntry
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'
        CommitSizesEntry -> IO CommitSizesEntry
forall (m :: * -> *) a. Monad m => a -> m a
return CommitSizesEntry
result''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
checksum'
    Maybe CommitSizesEntry -> IO (Maybe CommitSizesEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CommitSizesEntry
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method CommitSizesEntry::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "CommitSizesEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeCommitSizesEntry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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 (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
    Ptr CommitSizesEntry
entry' <- CommitSizesEntry -> IO (Ptr CommitSizesEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CommitSizesEntry
entry
    Ptr CommitSizesEntry
result <- Ptr CommitSizesEntry -> IO (Ptr CommitSizesEntry)
ostree_commit_sizes_entry_copy Ptr CommitSizesEntry
entry'
    Maybe CommitSizesEntry
maybeResult <- Ptr CommitSizesEntry
-> (Ptr CommitSizesEntry -> IO CommitSizesEntry)
-> IO (Maybe CommitSizesEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CommitSizesEntry
result ((Ptr CommitSizesEntry -> IO CommitSizesEntry)
 -> IO (Maybe CommitSizesEntry))
-> (Ptr CommitSizesEntry -> IO CommitSizesEntry)
-> IO (Maybe CommitSizesEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr CommitSizesEntry
result' -> do
        CommitSizesEntry
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'
        CommitSizesEntry -> IO CommitSizesEntry
forall (m :: * -> *) a. Monad m => a -> m a
return CommitSizesEntry
result''
    CommitSizesEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CommitSizesEntry
entry
    Maybe CommitSizesEntry -> IO (Maybe CommitSizesEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CommitSizesEntry
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.15/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" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeCommitSizesEntry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = 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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CommitSizesEntry
entry' <- CommitSizesEntry -> IO (Ptr CommitSizesEntry)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed CommitSizesEntry
entry
    Ptr CommitSizesEntry -> IO ()
ostree_commit_sizes_entry_free Ptr CommitSizesEntry
entry'
    CommitSizesEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CommitSizesEntry
entry
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
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.15/docs/GI-OSTree-Structs-CommitSizesEntry.html#v:commitSizesEntryFree"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveCommitSizesEntryMethod (t :: Symbol) (o :: *) :: * 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