{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a git configuration entry.

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

module GI.Ggit.Structs.ConfigEntry
    ( 

-- * Exported types
    ConfigEntry(..)                         ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [ref]("GI.Ggit.Structs.ConfigEntry#g:method:ref"), [unref]("GI.Ggit.Structs.ConfigEntry#g:method:unref").
-- 
-- ==== Getters
-- [getLevel]("GI.Ggit.Structs.ConfigEntry#g:method:getLevel"), [getName]("GI.Ggit.Structs.ConfigEntry#g:method:getName"), [getValue]("GI.Ggit.Structs.ConfigEntry#g:method:getValue").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveConfigEntryMethod                ,
#endif

-- ** getLevel #method:getLevel#

#if defined(ENABLE_OVERLOADING)
    ConfigEntryGetLevelMethodInfo           ,
#endif
    configEntryGetLevel                     ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    ConfigEntryGetNameMethodInfo            ,
#endif
    configEntryGetName                      ,


-- ** getValue #method:getValue#

#if defined(ENABLE_OVERLOADING)
    ConfigEntryGetValueMethodInfo           ,
#endif
    configEntryGetValue                     ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    ConfigEntryRefMethodInfo                ,
#endif
    configEntryRef                          ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    ConfigEntryUnrefMethodInfo              ,
#endif
    configEntryUnref                        ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

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

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

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

foreign import ccall "ggit_config_entry_get_type" c_ggit_config_entry_get_type :: 
    IO GType

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

instance B.Types.TypedObject ConfigEntry where
    glibType :: IO GType
glibType = IO GType
c_ggit_config_entry_get_type

instance B.Types.GBoxed ConfigEntry

-- | Convert 'ConfigEntry' 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 ConfigEntry) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_config_entry_get_type
    gvalueSet_ :: Ptr GValue -> Maybe ConfigEntry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ConfigEntry
P.Nothing = Ptr GValue -> Ptr ConfigEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr ConfigEntry
forall a. Ptr a
FP.nullPtr :: FP.Ptr ConfigEntry)
    gvalueSet_ Ptr GValue
gv (P.Just ConfigEntry
obj) = ConfigEntry -> (Ptr ConfigEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ConfigEntry
obj (Ptr GValue -> Ptr ConfigEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe ConfigEntry)
gvalueGet_ Ptr GValue
gv = do
        Ptr ConfigEntry
ptr <- Ptr GValue -> IO (Ptr ConfigEntry)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr ConfigEntry)
        if Ptr ConfigEntry
ptr Ptr ConfigEntry -> Ptr ConfigEntry -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ConfigEntry
forall a. Ptr a
FP.nullPtr
        then ConfigEntry -> Maybe ConfigEntry
forall a. a -> Maybe a
P.Just (ConfigEntry -> Maybe ConfigEntry)
-> IO ConfigEntry -> IO (Maybe ConfigEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ConfigEntry -> ConfigEntry)
-> Ptr ConfigEntry -> IO ConfigEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr ConfigEntry -> ConfigEntry
ConfigEntry Ptr ConfigEntry
ptr
        else Maybe ConfigEntry -> IO (Maybe ConfigEntry)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ConfigEntry
forall a. Maybe a
P.Nothing
        
    


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ConfigEntry
type instance O.AttributeList ConfigEntry = ConfigEntryAttributeList
type ConfigEntryAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method ConfigEntry::get_level
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "ConfigEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitConfigEntry."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "ConfigLevel" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_config_entry_get_level" ggit_config_entry_get_level :: 
    Ptr ConfigEntry ->                      -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"})
    IO CInt

-- | Gets the t'GI.Ggit.Enums.ConfigLevel' of /@entry@/.
configEntryGetLevel ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ConfigEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.ConfigEntry.ConfigEntry'.
    -> m Ggit.Enums.ConfigLevel
    -- ^ __Returns:__ the t'GI.Ggit.Enums.ConfigLevel' of /@entry@/.
configEntryGetLevel :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ConfigEntry -> m ConfigLevel
configEntryGetLevel ConfigEntry
entry = IO ConfigLevel -> m ConfigLevel
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ConfigLevel -> m ConfigLevel)
-> IO ConfigLevel -> m ConfigLevel
forall a b. (a -> b) -> a -> b
$ do
    Ptr ConfigEntry
entry' <- ConfigEntry -> IO (Ptr ConfigEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ConfigEntry
entry
    CInt
result <- Ptr ConfigEntry -> IO CInt
ggit_config_entry_get_level Ptr ConfigEntry
entry'
    let result' :: ConfigLevel
result' = (Int -> ConfigLevel
forall a. Enum a => Int -> a
toEnum (Int -> ConfigLevel) -> (CInt -> Int) -> CInt -> ConfigLevel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
    ConfigEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ConfigEntry
entry
    ConfigLevel -> IO ConfigLevel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ConfigLevel
result'

#if defined(ENABLE_OVERLOADING)
data ConfigEntryGetLevelMethodInfo
instance (signature ~ (m Ggit.Enums.ConfigLevel), MonadIO m) => O.OverloadedMethod ConfigEntryGetLevelMethodInfo ConfigEntry signature where
    overloadedMethod = configEntryGetLevel

instance O.OverloadedMethodInfo ConfigEntryGetLevelMethodInfo ConfigEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.ConfigEntry.configEntryGetLevel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-ConfigEntry.html#v:configEntryGetLevel"
        })


#endif

-- method ConfigEntry::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "ConfigEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitConfigEntry."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_config_entry_get_name" ggit_config_entry_get_name :: 
    Ptr ConfigEntry ->                      -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"})
    IO CString

-- | Gets the name of /@entry@/.
configEntryGetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ConfigEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.ConfigEntry.ConfigEntry'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of /@entry@/ or 'P.Nothing'.
configEntryGetName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ConfigEntry -> m (Maybe Text)
configEntryGetName ConfigEntry
entry = 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
$ do
    Ptr ConfigEntry
entry' <- ConfigEntry -> IO (Ptr ConfigEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ConfigEntry
entry
    CString
result <- Ptr ConfigEntry -> IO CString
ggit_config_entry_get_name Ptr ConfigEntry
entry'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    ConfigEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ConfigEntry
entry
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data ConfigEntryGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod ConfigEntryGetNameMethodInfo ConfigEntry signature where
    overloadedMethod = configEntryGetName

instance O.OverloadedMethodInfo ConfigEntryGetNameMethodInfo ConfigEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.ConfigEntry.configEntryGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-ConfigEntry.html#v:configEntryGetName"
        })


#endif

-- method ConfigEntry::get_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "ConfigEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitConfigEntry."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_config_entry_get_value" ggit_config_entry_get_value :: 
    Ptr ConfigEntry ->                      -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"})
    IO CString

-- | Gets the value of /@entry@/.
configEntryGetValue ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ConfigEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.ConfigEntry.ConfigEntry'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the value of /@entry@/ or 'P.Nothing'.
configEntryGetValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ConfigEntry -> m (Maybe Text)
configEntryGetValue ConfigEntry
entry = 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
$ do
    Ptr ConfigEntry
entry' <- ConfigEntry -> IO (Ptr ConfigEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ConfigEntry
entry
    CString
result <- Ptr ConfigEntry -> IO CString
ggit_config_entry_get_value Ptr ConfigEntry
entry'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    ConfigEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ConfigEntry
entry
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data ConfigEntryGetValueMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod ConfigEntryGetValueMethodInfo ConfigEntry signature where
    overloadedMethod = configEntryGetValue

instance O.OverloadedMethodInfo ConfigEntryGetValueMethodInfo ConfigEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.ConfigEntry.configEntryGetValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-ConfigEntry.html#v:configEntryGetValue"
        })


#endif

-- method ConfigEntry::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "ConfigEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitConfigEntry."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "ConfigEntry" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_config_entry_ref" ggit_config_entry_ref :: 
    Ptr ConfigEntry ->                      -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"})
    IO (Ptr ConfigEntry)

-- | Atomically increments the reference count of /@entry@/ by one.
-- This function is MT-safe and may be called from any thread.
configEntryRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ConfigEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.ConfigEntry.ConfigEntry'.
    -> m (Maybe ConfigEntry)
    -- ^ __Returns:__ a t'GI.Ggit.Structs.ConfigEntry.ConfigEntry' or 'P.Nothing'.
configEntryRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ConfigEntry -> m (Maybe ConfigEntry)
configEntryRef ConfigEntry
entry = IO (Maybe ConfigEntry) -> m (Maybe ConfigEntry)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ConfigEntry) -> m (Maybe ConfigEntry))
-> IO (Maybe ConfigEntry) -> m (Maybe ConfigEntry)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ConfigEntry
entry' <- ConfigEntry -> IO (Ptr ConfigEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ConfigEntry
entry
    Ptr ConfigEntry
result <- Ptr ConfigEntry -> IO (Ptr ConfigEntry)
ggit_config_entry_ref Ptr ConfigEntry
entry'
    Maybe ConfigEntry
maybeResult <- Ptr ConfigEntry
-> (Ptr ConfigEntry -> IO ConfigEntry) -> IO (Maybe ConfigEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ConfigEntry
result ((Ptr ConfigEntry -> IO ConfigEntry) -> IO (Maybe ConfigEntry))
-> (Ptr ConfigEntry -> IO ConfigEntry) -> IO (Maybe ConfigEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr ConfigEntry
result' -> do
        ConfigEntry
result'' <- ((ManagedPtr ConfigEntry -> ConfigEntry)
-> Ptr ConfigEntry -> IO ConfigEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr ConfigEntry -> ConfigEntry
ConfigEntry) Ptr ConfigEntry
result'
        ConfigEntry -> IO ConfigEntry
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ConfigEntry
result''
    ConfigEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ConfigEntry
entry
    Maybe ConfigEntry -> IO (Maybe ConfigEntry)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ConfigEntry
maybeResult

#if defined(ENABLE_OVERLOADING)
data ConfigEntryRefMethodInfo
instance (signature ~ (m (Maybe ConfigEntry)), MonadIO m) => O.OverloadedMethod ConfigEntryRefMethodInfo ConfigEntry signature where
    overloadedMethod = configEntryRef

instance O.OverloadedMethodInfo ConfigEntryRefMethodInfo ConfigEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.ConfigEntry.configEntryRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-ConfigEntry.html#v:configEntryRef"
        })


#endif

-- method ConfigEntry::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "ConfigEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitConfigEntry."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_config_entry_unref" ggit_config_entry_unref :: 
    Ptr ConfigEntry ->                      -- entry : TInterface (Name {namespace = "Ggit", name = "ConfigEntry"})
    IO ()

-- | Atomically decrements the reference count of /@entry@/ by one.
-- If the reference count drops to 0, /@entry@/ is freed.
configEntryUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ConfigEntry
    -- ^ /@entry@/: a t'GI.Ggit.Structs.ConfigEntry.ConfigEntry'.
    -> m ()
configEntryUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ConfigEntry -> m ()
configEntryUnref ConfigEntry
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
    Ptr ConfigEntry
entry' <- ConfigEntry -> IO (Ptr ConfigEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ConfigEntry
entry
    Ptr ConfigEntry -> IO ()
ggit_config_entry_unref Ptr ConfigEntry
entry'
    ConfigEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ConfigEntry
entry
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ConfigEntryUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ConfigEntryUnrefMethodInfo ConfigEntry signature where
    overloadedMethod = configEntryUnref

instance O.OverloadedMethodInfo ConfigEntryUnrefMethodInfo ConfigEntry where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Ggit.Structs.ConfigEntry.configEntryUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-ConfigEntry.html#v:configEntryUnref"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveConfigEntryMethod (t :: Symbol) (o :: *) :: * where
    ResolveConfigEntryMethod "ref" o = ConfigEntryRefMethodInfo
    ResolveConfigEntryMethod "unref" o = ConfigEntryUnrefMethodInfo
    ResolveConfigEntryMethod "getLevel" o = ConfigEntryGetLevelMethodInfo
    ResolveConfigEntryMethod "getName" o = ConfigEntryGetNameMethodInfo
    ResolveConfigEntryMethod "getValue" o = ConfigEntryGetValueMethodInfo
    ResolveConfigEntryMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif