{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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
-- ** Overloaded methods #method:Overloaded methods#

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

import {-# 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
/= :: ConfigEntry -> ConfigEntry -> Bool
$c/= :: ConfigEntry -> ConfigEntry -> Bool
== :: ConfigEntry -> ConfigEntry -> Bool
$c== :: 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' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue ConfigEntry where
    toGValue :: ConfigEntry -> IO GValue
toGValue ConfigEntry
o = do
        GType
gtype <- IO GType
c_ggit_config_entry_get_type
        ConfigEntry -> (Ptr ConfigEntry -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ConfigEntry
o (GType
-> (GValue -> Ptr ConfigEntry -> IO ())
-> Ptr ConfigEntry
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ConfigEntry -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO ConfigEntry
fromGValue GValue
gv = do
        Ptr ConfigEntry
ptr <- GValue -> IO (Ptr ConfigEntry)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr ConfigEntry)
        (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
        
    


#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 :: ConfigEntry -> m ConfigLevel
configEntryGetLevel ConfigEntry
entry = IO ConfigLevel -> m ConfigLevel
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 (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.MethodInfo ConfigEntryGetLevelMethodInfo ConfigEntry signature where
    overloadedMethod = 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 :: ConfigEntry -> m (Maybe Text)
configEntryGetName ConfigEntry
entry = 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
$ 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 (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 (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.MethodInfo ConfigEntryGetNameMethodInfo ConfigEntry signature where
    overloadedMethod = 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 :: ConfigEntry -> m (Maybe Text)
configEntryGetValue ConfigEntry
entry = 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
$ 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 (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 (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.MethodInfo ConfigEntryGetValueMethodInfo ConfigEntry signature where
    overloadedMethod = 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 :: ConfigEntry -> m (Maybe ConfigEntry)
configEntryRef ConfigEntry
entry = IO (Maybe ConfigEntry) -> m (Maybe ConfigEntry)
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 (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 (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.MethodInfo ConfigEntryRefMethodInfo ConfigEntry signature where
    overloadedMethod = 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 :: ConfigEntry -> m ()
configEntryUnref ConfigEntry
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 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 (m :: * -> *) a. Monad m => a -> m a
return ()

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

#endif