{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Structs.TreeEntry
(
TreeEntry(..) ,
#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.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.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
newtype TreeEntry = TreeEntry (SP.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)
instance SP.ManagedPtrNewtype TreeEntry where
toManagedPtr :: TreeEntry -> ManagedPtr TreeEntry
toManagedPtr (TreeEntry ManagedPtr TreeEntry
p) = ManagedPtr TreeEntry
p
foreign import ccall "ggit_tree_entry_get_type" c_ggit_tree_entry_get_type ::
IO GType
type instance O.ParentTypes TreeEntry = '[]
instance O.HasParentTypes TreeEntry
instance B.Types.TypedObject TreeEntry where
glibType :: IO GType
glibType = IO GType
c_ggit_tree_entry_get_type
instance B.Types.GBoxed TreeEntry
instance B.GValue.IsGValue (Maybe TreeEntry) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_tree_entry_get_type
gvalueSet_ :: Ptr GValue -> Maybe TreeEntry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TreeEntry
P.Nothing = Ptr GValue -> Ptr TreeEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr TreeEntry
forall a. Ptr a
FP.nullPtr :: FP.Ptr TreeEntry)
gvalueSet_ Ptr GValue
gv (P.Just TreeEntry
obj) = TreeEntry -> (Ptr TreeEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeEntry
obj (Ptr GValue -> Ptr TreeEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TreeEntry)
gvalueGet_ Ptr GValue
gv = do
Ptr TreeEntry
ptr <- Ptr GValue -> IO (Ptr TreeEntry)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr TreeEntry)
if Ptr TreeEntry
ptr Ptr TreeEntry -> Ptr TreeEntry -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TreeEntry
forall a. Ptr a
FP.nullPtr
then TreeEntry -> Maybe TreeEntry
forall a. a -> Maybe a
P.Just (TreeEntry -> Maybe TreeEntry)
-> IO TreeEntry -> IO (Maybe TreeEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr TreeEntry -> TreeEntry
TreeEntry Ptr TreeEntry
ptr
else Maybe TreeEntry -> IO (Maybe TreeEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreeEntry
forall a. Maybe a
P.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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m FileMode
treeEntryGetFileMode 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.OverloadedMethod TreeEntryGetFileModeMethodInfo TreeEntry signature where
overloadedMethod = treeEntryGetFileMode
instance O.OverloadedMethodInfo TreeEntryGetFileModeMethodInfo TreeEntry where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryGetFileMode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m (Maybe OId)
treeEntryGetId 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
$ \Ptr OId
result' -> do
OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, GBoxed 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.OverloadedMethod TreeEntryGetIdMethodInfo TreeEntry signature where
overloadedMethod = treeEntryGetId
instance O.OverloadedMethodInfo TreeEntryGetIdMethodInfo TreeEntry where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryGetId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m (Maybe Text)
treeEntryGetName 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
$ \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.OverloadedMethod TreeEntryGetNameMethodInfo TreeEntry signature where
overloadedMethod = treeEntryGetName
instance O.OverloadedMethodInfo TreeEntryGetNameMethodInfo TreeEntry where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryGetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m GType
treeEntryGetObjectType 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.OverloadedMethod TreeEntryGetObjectTypeMethodInfo TreeEntry signature where
overloadedMethod = treeEntryGetObjectType
instance O.OverloadedMethodInfo TreeEntryGetObjectTypeMethodInfo TreeEntry where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryGetObjectType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m (Maybe TreeEntry)
treeEntryRef 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
$ \Ptr TreeEntry
result' -> do
TreeEntry
result'' <- ((ManagedPtr TreeEntry -> TreeEntry)
-> Ptr TreeEntry -> IO TreeEntry
forall a.
(HasCallStack, GBoxed 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.OverloadedMethod TreeEntryRefMethodInfo TreeEntry signature where
overloadedMethod = treeEntryRef
instance O.OverloadedMethodInfo TreeEntryRefMethodInfo TreeEntry where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-TreeEntry.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TreeEntry -> m ()
treeEntryUnref 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.OverloadedMethod TreeEntryUnrefMethodInfo TreeEntry signature where
overloadedMethod = treeEntryUnref
instance O.OverloadedMethodInfo TreeEntryUnrefMethodInfo TreeEntry where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.TreeEntry.treeEntryUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Structs-TreeEntry.html#v: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.OverloadedMethod 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
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTreeEntryMethod t TreeEntry, O.OverloadedMethod info TreeEntry p, R.HasField t TreeEntry p) => R.HasField t TreeEntry p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTreeEntryMethod t TreeEntry, O.OverloadedMethodInfo info TreeEntry) => OL.IsLabel t (O.MethodProxy info TreeEntry) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif