{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Structs.TreeEntry
(
TreeEntry(..) ,
noTreeEntry ,
#if defined(ENABLE_OVERLOADING)
ResolveTreeEntryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TreeEntryGetFileModeMethodInfo ,
#endif
treeEntryGetFileMode ,
#if defined(ENABLE_OVERLOADING)
TreeEntryGetIdMethodInfo ,
#endif
treeEntryGetId ,
#if defined(ENABLE_OVERLOADING)
TreeEntryGetNameMethodInfo ,
#endif
treeEntryGetName ,
#if defined(ENABLE_OVERLOADING)
TreeEntryGetObjectTypeMethodInfo ,
#endif
treeEntryGetObjectType ,
#if defined(ENABLE_OVERLOADING)
TreeEntryRefMethodInfo ,
#endif
treeEntryRef ,
#if defined(ENABLE_OVERLOADING)
TreeEntryUnrefMethodInfo ,
#endif
treeEntryUnref ,
) 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.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 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
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
newtype TreeEntry = TreeEntry (ManagedPtr TreeEntry)
deriving (TreeEntry -> TreeEntry -> Bool
(TreeEntry -> TreeEntry -> Bool)
-> (TreeEntry -> TreeEntry -> Bool) -> Eq TreeEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeEntry -> TreeEntry -> Bool
$c/= :: TreeEntry -> TreeEntry -> Bool
== :: TreeEntry -> TreeEntry -> Bool
$c== :: TreeEntry -> TreeEntry -> Bool
Eq)
foreign import ccall "ggit_tree_entry_get_type" c_ggit_tree_entry_get_type ::
IO GType
instance BoxedObject TreeEntry where
boxedType :: TreeEntry -> IO GType
boxedType _ = IO GType
c_ggit_tree_entry_get_type
instance B.GValue.IsGValue TreeEntry where
toGValue :: TreeEntry -> IO GValue
toGValue o :: TreeEntry
o = do
GType
gtype <- IO GType
c_ggit_tree_entry_get_type
TreeEntry -> (Ptr TreeEntry -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeEntry
o (GType
-> (GValue -> Ptr TreeEntry -> IO ()) -> Ptr TreeEntry -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr TreeEntry -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO TreeEntry
fromGValue gv :: GValue
gv = do
Ptr TreeEntry
ptr <- GValue -> IO (Ptr TreeEntry)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr TreeEntry)
(ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr TreeEntry -> TreeEntry
TreeEntry Ptr TreeEntry
ptr
noTreeEntry :: Maybe TreeEntry
noTreeEntry :: Maybe TreeEntry
noTreeEntry = Maybe TreeEntry
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TreeEntry
type instance O.AttributeList TreeEntry = TreeEntryAttributeList
type TreeEntryAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_tree_entry_get_file_mode" ggit_tree_entry_get_file_mode ::
Ptr TreeEntry ->
IO CUInt
treeEntryGetFileMode ::
(B.CallStack.HasCallStack, MonadIO m) =>
TreeEntry
-> m Ggit.Enums.FileMode
treeEntryGetFileMode :: TreeEntry -> m FileMode
treeEntryGetFileMode entry :: TreeEntry
entry = IO FileMode -> m FileMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FileMode -> m FileMode) -> IO FileMode -> m FileMode
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
CUInt
result <- Ptr TreeEntry -> IO CUInt
ggit_tree_entry_get_file_mode Ptr TreeEntry
entry'
let result' :: FileMode
result' = (Int -> FileMode
forall a. Enum a => Int -> a
toEnum (Int -> FileMode) -> (CUInt -> Int) -> CUInt -> FileMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
FileMode -> IO FileMode
forall (m :: * -> *) a. Monad m => a -> m a
return FileMode
result'
#if defined(ENABLE_OVERLOADING)
data TreeEntryGetFileModeMethodInfo
instance (signature ~ (m Ggit.Enums.FileMode), MonadIO m) => O.MethodInfo TreeEntryGetFileModeMethodInfo TreeEntry signature where
overloadedMethod = treeEntryGetFileMode
#endif
foreign import ccall "ggit_tree_entry_get_id" ggit_tree_entry_get_id ::
Ptr TreeEntry ->
IO (Ptr Ggit.OId.OId)
treeEntryGetId ::
(B.CallStack.HasCallStack, MonadIO m) =>
TreeEntry
-> m (Maybe Ggit.OId.OId)
treeEntryGetId :: TreeEntry -> m (Maybe OId)
treeEntryGetId entry :: TreeEntry
entry = IO (Maybe OId) -> m (Maybe OId)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe OId) -> m (Maybe OId))
-> IO (Maybe OId) -> m (Maybe OId)
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
Ptr OId
result <- Ptr TreeEntry -> IO (Ptr OId)
ggit_tree_entry_get_id Ptr TreeEntry
entry'
Maybe OId
maybeResult <- Ptr OId -> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr OId
result ((Ptr OId -> IO OId) -> IO (Maybe OId))
-> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr OId
result' -> do
OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OId -> OId
Ggit.OId.OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeEntryGetIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo TreeEntryGetIdMethodInfo TreeEntry signature where
overloadedMethod = treeEntryGetId
#endif
foreign import ccall "ggit_tree_entry_get_name" ggit_tree_entry_get_name ::
Ptr TreeEntry ->
IO CString
treeEntryGetName ::
(B.CallStack.HasCallStack, MonadIO m) =>
TreeEntry
-> m (Maybe T.Text)
treeEntryGetName :: TreeEntry -> m (Maybe Text)
treeEntryGetName entry :: TreeEntry
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 TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
CString
result <- Ptr TreeEntry -> IO CString
ggit_tree_entry_get_name Ptr TreeEntry
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
$ \result' :: 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''
TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeEntryGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo TreeEntryGetNameMethodInfo TreeEntry signature where
overloadedMethod = treeEntryGetName
#endif
foreign import ccall "ggit_tree_entry_get_object_type" ggit_tree_entry_get_object_type ::
Ptr TreeEntry ->
IO CGType
treeEntryGetObjectType ::
(B.CallStack.HasCallStack, MonadIO m) =>
TreeEntry
-> m GType
treeEntryGetObjectType :: TreeEntry -> m GType
treeEntryGetObjectType entry :: TreeEntry
entry = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
CGType
result <- Ptr TreeEntry -> IO CGType
ggit_tree_entry_get_object_type Ptr TreeEntry
entry'
let result' :: GType
result' = CGType -> GType
GType CGType
result
TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'
#if defined(ENABLE_OVERLOADING)
data TreeEntryGetObjectTypeMethodInfo
instance (signature ~ (m GType), MonadIO m) => O.MethodInfo TreeEntryGetObjectTypeMethodInfo TreeEntry signature where
overloadedMethod = treeEntryGetObjectType
#endif
foreign import ccall "ggit_tree_entry_ref" ggit_tree_entry_ref ::
Ptr TreeEntry ->
IO (Ptr TreeEntry)
treeEntryRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
TreeEntry
-> m (Maybe TreeEntry)
treeEntryRef :: TreeEntry -> m (Maybe TreeEntry)
treeEntryRef entry :: TreeEntry
entry = IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TreeEntry) -> m (Maybe TreeEntry))
-> IO (Maybe TreeEntry) -> m (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ do
Ptr TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
Ptr TreeEntry
result <- Ptr TreeEntry -> IO (Ptr TreeEntry)
ggit_tree_entry_ref Ptr TreeEntry
entry'
Maybe TreeEntry
maybeResult <- Ptr TreeEntry
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreeEntry
result ((Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry))
-> (Ptr TreeEntry -> IO TreeEntry) -> IO (Maybe TreeEntry)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr TreeEntry
result' -> do
TreeEntry
result'' <- ((ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr TreeEntry -> TreeEntry
TreeEntry) Ptr TreeEntry
result'
TreeEntry -> IO TreeEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TreeEntry
result''
TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
Maybe TreeEntry -> IO (Maybe TreeEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeEntry
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeEntryRefMethodInfo
instance (signature ~ (m (Maybe TreeEntry)), MonadIO m) => O.MethodInfo TreeEntryRefMethodInfo TreeEntry signature where
overloadedMethod = treeEntryRef
#endif
foreign import ccall "ggit_tree_entry_unref" ggit_tree_entry_unref ::
Ptr TreeEntry ->
IO ()
treeEntryUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
TreeEntry
-> m ()
treeEntryUnref :: TreeEntry -> m ()
treeEntryUnref entry :: TreeEntry
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 TreeEntry
entry' <- TreeEntry -> IO (Ptr TreeEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeEntry
entry
Ptr TreeEntry -> IO ()
ggit_tree_entry_unref Ptr TreeEntry
entry'
TreeEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeEntryUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TreeEntryUnrefMethodInfo TreeEntry signature where
overloadedMethod = treeEntryUnref
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTreeEntryMethod (t :: Symbol) (o :: *) :: * where
ResolveTreeEntryMethod "ref" o = TreeEntryRefMethodInfo
ResolveTreeEntryMethod "unref" o = TreeEntryUnrefMethodInfo
ResolveTreeEntryMethod "getFileMode" o = TreeEntryGetFileModeMethodInfo
ResolveTreeEntryMethod "getId" o = TreeEntryGetIdMethodInfo
ResolveTreeEntryMethod "getName" o = TreeEntryGetNameMethodInfo
ResolveTreeEntryMethod "getObjectType" o = TreeEntryGetObjectTypeMethodInfo
ResolveTreeEntryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTreeEntryMethod t TreeEntry, O.MethodInfo info TreeEntry p) => OL.IsLabel t (TreeEntry -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif