{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Structs.ConfigEntry
(
ConfigEntry(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveConfigEntryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ConfigEntryGetLevelMethodInfo ,
#endif
configEntryGetLevel ,
#if defined(ENABLE_OVERLOADING)
ConfigEntryGetNameMethodInfo ,
#endif
configEntryGetName ,
#if defined(ENABLE_OVERLOADING)
ConfigEntryGetValueMethodInfo ,
#endif
configEntryGetValue ,
#if defined(ENABLE_OVERLOADING)
ConfigEntryRefMethodInfo ,
#endif
configEntryRef ,
#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
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
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
foreign import ccall "ggit_config_entry_get_level" ggit_config_entry_get_level ::
Ptr ConfigEntry ->
IO CInt
configEntryGetLevel ::
(B.CallStack.HasCallStack, MonadIO m) =>
ConfigEntry
-> m Ggit.Enums.ConfigLevel
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
foreign import ccall "ggit_config_entry_get_name" ggit_config_entry_get_name ::
Ptr ConfigEntry ->
IO CString
configEntryGetName ::
(B.CallStack.HasCallStack, MonadIO m) =>
ConfigEntry
-> m (Maybe T.Text)
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
foreign import ccall "ggit_config_entry_get_value" ggit_config_entry_get_value ::
Ptr ConfigEntry ->
IO CString
configEntryGetValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
ConfigEntry
-> m (Maybe T.Text)
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
foreign import ccall "ggit_config_entry_ref" ggit_config_entry_ref ::
Ptr ConfigEntry ->
IO (Ptr ConfigEntry)
configEntryRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
ConfigEntry
-> m (Maybe ConfigEntry)
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
foreign import ccall "ggit_config_entry_unref" ggit_config_entry_unref ::
Ptr ConfigEntry ->
IO ()
configEntryUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
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