{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Structs.IndexEntry
(
IndexEntry(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveIndexEntryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
IndexEntryGetDevMethodInfo ,
#endif
indexEntryGetDev ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetFileSizeMethodInfo ,
#endif
indexEntryGetFileSize ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetFlagsMethodInfo ,
#endif
indexEntryGetFlags ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetFlagsExtendedMethodInfo ,
#endif
indexEntryGetFlagsExtended ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetGidMethodInfo ,
#endif
indexEntryGetGid ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetIdMethodInfo ,
#endif
indexEntryGetId ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetInoMethodInfo ,
#endif
indexEntryGetIno ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetModeMethodInfo ,
#endif
indexEntryGetMode ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetPathMethodInfo ,
#endif
indexEntryGetPath ,
#if defined(ENABLE_OVERLOADING)
IndexEntryGetUidMethodInfo ,
#endif
indexEntryGetUid ,
#if defined(ENABLE_OVERLOADING)
IndexEntryIsConflictMethodInfo ,
#endif
indexEntryIsConflict ,
#if defined(ENABLE_OVERLOADING)
IndexEntryRefMethodInfo ,
#endif
indexEntryRef ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetCommitMethodInfo ,
#endif
indexEntrySetCommit ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetDevMethodInfo ,
#endif
indexEntrySetDev ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetFileSizeMethodInfo ,
#endif
indexEntrySetFileSize ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetFlagsMethodInfo ,
#endif
indexEntrySetFlags ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetFlagsExtendedMethodInfo ,
#endif
indexEntrySetFlagsExtended ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetGidMethodInfo ,
#endif
indexEntrySetGid ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetIdMethodInfo ,
#endif
indexEntrySetId ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetInoMethodInfo ,
#endif
indexEntrySetIno ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetModeMethodInfo ,
#endif
indexEntrySetMode ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetPathMethodInfo ,
#endif
indexEntrySetPath ,
#if defined(ENABLE_OVERLOADING)
IndexEntrySetUidMethodInfo ,
#endif
indexEntrySetUid ,
#if defined(ENABLE_OVERLOADING)
IndexEntryStatMethodInfo ,
#endif
indexEntryStat ,
#if defined(ENABLE_OVERLOADING)
IndexEntryUnrefMethodInfo ,
#endif
indexEntryUnref ,
) 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.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.Objects.Commit as Ggit.Commit
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import qualified GI.Gio.Interfaces.File as Gio.File
newtype IndexEntry = IndexEntry (SP.ManagedPtr IndexEntry)
deriving (IndexEntry -> IndexEntry -> Bool
(IndexEntry -> IndexEntry -> Bool)
-> (IndexEntry -> IndexEntry -> Bool) -> Eq IndexEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IndexEntry -> IndexEntry -> Bool
$c/= :: IndexEntry -> IndexEntry -> Bool
== :: IndexEntry -> IndexEntry -> Bool
$c== :: IndexEntry -> IndexEntry -> Bool
Eq)
instance SP.ManagedPtrNewtype IndexEntry where
toManagedPtr :: IndexEntry -> ManagedPtr IndexEntry
toManagedPtr (IndexEntry ManagedPtr IndexEntry
p) = ManagedPtr IndexEntry
p
foreign import ccall "ggit_index_entry_get_type" c_ggit_index_entry_get_type ::
IO GType
type instance O.ParentTypes IndexEntry = '[]
instance O.HasParentTypes IndexEntry
instance B.Types.TypedObject IndexEntry where
glibType :: IO GType
glibType = IO GType
c_ggit_index_entry_get_type
instance B.Types.GBoxed IndexEntry
instance B.GValue.IsGValue (Maybe IndexEntry) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_index_entry_get_type
gvalueSet_ :: Ptr GValue -> Maybe IndexEntry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe IndexEntry
P.Nothing = Ptr GValue -> Ptr IndexEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr IndexEntry
forall a. Ptr a
FP.nullPtr :: FP.Ptr IndexEntry)
gvalueSet_ Ptr GValue
gv (P.Just IndexEntry
obj) = IndexEntry -> (Ptr IndexEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr IndexEntry
obj (Ptr GValue -> Ptr IndexEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe IndexEntry)
gvalueGet_ Ptr GValue
gv = do
Ptr IndexEntry
ptr <- Ptr GValue -> IO (Ptr IndexEntry)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr IndexEntry)
if Ptr IndexEntry
ptr Ptr IndexEntry -> Ptr IndexEntry -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr IndexEntry
forall a. Ptr a
FP.nullPtr
then IndexEntry -> Maybe IndexEntry
forall a. a -> Maybe a
P.Just (IndexEntry -> Maybe IndexEntry)
-> IO IndexEntry -> IO (Maybe IndexEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr IndexEntry -> IndexEntry)
-> Ptr IndexEntry -> IO IndexEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr IndexEntry -> IndexEntry
IndexEntry Ptr IndexEntry
ptr
else Maybe IndexEntry -> IO (Maybe IndexEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IndexEntry
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList IndexEntry
type instance O.AttributeList IndexEntry = IndexEntryAttributeList
type IndexEntryAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_index_entry_get_dev" ggit_index_entry_get_dev ::
Ptr IndexEntry ->
IO Word32
indexEntryGetDev ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Word32
indexEntryGetDev :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Word32
indexEntryGetDev IndexEntry
entry = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Word32
result <- Ptr IndexEntry -> IO Word32
ggit_index_entry_get_dev Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetDevMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod IndexEntryGetDevMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetDev
instance O.OverloadedMethodInfo IndexEntryGetDevMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetDev",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetDev"
}
#endif
foreign import ccall "ggit_index_entry_get_file_size" ggit_index_entry_get_file_size ::
Ptr IndexEntry ->
IO Int64
indexEntryGetFileSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Int64
indexEntryGetFileSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Int64
indexEntryGetFileSize IndexEntry
entry = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Int64
result <- Ptr IndexEntry -> IO Int64
ggit_index_entry_get_file_size Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Int64 -> IO Int64
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetFileSizeMethodInfo
instance (signature ~ (m Int64), MonadIO m) => O.OverloadedMethod IndexEntryGetFileSizeMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetFileSize
instance O.OverloadedMethodInfo IndexEntryGetFileSizeMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetFileSize",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetFileSize"
}
#endif
foreign import ccall "ggit_index_entry_get_flags" ggit_index_entry_get_flags ::
Ptr IndexEntry ->
IO Word32
indexEntryGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Word32
indexEntryGetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Word32
indexEntryGetFlags IndexEntry
entry = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Word32
result <- Ptr IndexEntry -> IO Word32
ggit_index_entry_get_flags Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetFlagsMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod IndexEntryGetFlagsMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetFlags
instance O.OverloadedMethodInfo IndexEntryGetFlagsMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetFlags",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetFlags"
}
#endif
foreign import ccall "ggit_index_entry_get_flags_extended" ggit_index_entry_get_flags_extended ::
Ptr IndexEntry ->
IO Word32
indexEntryGetFlagsExtended ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Word32
indexEntryGetFlagsExtended :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Word32
indexEntryGetFlagsExtended IndexEntry
entry = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Word32
result <- Ptr IndexEntry -> IO Word32
ggit_index_entry_get_flags_extended Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetFlagsExtendedMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod IndexEntryGetFlagsExtendedMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetFlagsExtended
instance O.OverloadedMethodInfo IndexEntryGetFlagsExtendedMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetFlagsExtended",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetFlagsExtended"
}
#endif
foreign import ccall "ggit_index_entry_get_gid" ggit_index_entry_get_gid ::
Ptr IndexEntry ->
IO Word32
indexEntryGetGid ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Word32
indexEntryGetGid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Word32
indexEntryGetGid IndexEntry
entry = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Word32
result <- Ptr IndexEntry -> IO Word32
ggit_index_entry_get_gid Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetGidMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod IndexEntryGetGidMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetGid
instance O.OverloadedMethodInfo IndexEntryGetGidMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetGid",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetGid"
}
#endif
foreign import ccall "ggit_index_entry_get_id" ggit_index_entry_get_id ::
Ptr IndexEntry ->
IO (Ptr Ggit.OId.OId)
indexEntryGetId ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m (Maybe Ggit.OId.OId)
indexEntryGetId :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m (Maybe OId)
indexEntryGetId IndexEntry
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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr OId
result <- Ptr IndexEntry -> IO (Ptr OId)
ggit_index_entry_get_id Ptr IndexEntry
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''
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.OverloadedMethod IndexEntryGetIdMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetId
instance O.OverloadedMethodInfo IndexEntryGetIdMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetId",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetId"
}
#endif
foreign import ccall "ggit_index_entry_get_ino" ggit_index_entry_get_ino ::
Ptr IndexEntry ->
IO Word32
indexEntryGetIno ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Word32
indexEntryGetIno :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Word32
indexEntryGetIno IndexEntry
entry = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Word32
result <- Ptr IndexEntry -> IO Word32
ggit_index_entry_get_ino Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetInoMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod IndexEntryGetInoMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetIno
instance O.OverloadedMethodInfo IndexEntryGetInoMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetIno",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetIno"
}
#endif
foreign import ccall "ggit_index_entry_get_mode" ggit_index_entry_get_mode ::
Ptr IndexEntry ->
IO Word32
indexEntryGetMode ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Word32
indexEntryGetMode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Word32
indexEntryGetMode IndexEntry
entry = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Word32
result <- Ptr IndexEntry -> IO Word32
ggit_index_entry_get_mode Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetModeMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod IndexEntryGetModeMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetMode
instance O.OverloadedMethodInfo IndexEntryGetModeMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetMode",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetMode"
}
#endif
foreign import ccall "ggit_index_entry_get_path" ggit_index_entry_get_path ::
Ptr IndexEntry ->
IO CString
indexEntryGetPath ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m T.Text
indexEntryGetPath :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Text
indexEntryGetPath IndexEntry
entry = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
CString
result <- Ptr IndexEntry -> IO CString
ggit_index_entry_get_path Ptr IndexEntry
entry'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"indexEntryGetPath" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetPathMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod IndexEntryGetPathMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetPath
instance O.OverloadedMethodInfo IndexEntryGetPathMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetPath",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetPath"
}
#endif
foreign import ccall "ggit_index_entry_get_uid" ggit_index_entry_get_uid ::
Ptr IndexEntry ->
IO Word32
indexEntryGetUid ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Word32
indexEntryGetUid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Word32
indexEntryGetUid IndexEntry
entry = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Word32
result <- Ptr IndexEntry -> IO Word32
ggit_index_entry_get_uid Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data IndexEntryGetUidMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod IndexEntryGetUidMethodInfo IndexEntry signature where
overloadedMethod = indexEntryGetUid
instance O.OverloadedMethodInfo IndexEntryGetUidMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryGetUid",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryGetUid"
}
#endif
foreign import ccall "ggit_index_entry_is_conflict" ggit_index_entry_is_conflict ::
Ptr IndexEntry ->
IO CInt
indexEntryIsConflict ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m Bool
indexEntryIsConflict :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m Bool
indexEntryIsConflict IndexEntry
entry = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
CInt
result <- Ptr IndexEntry -> IO CInt
ggit_index_entry_is_conflict Ptr IndexEntry
entry'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data IndexEntryIsConflictMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod IndexEntryIsConflictMethodInfo IndexEntry signature where
overloadedMethod = indexEntryIsConflict
instance O.OverloadedMethodInfo IndexEntryIsConflictMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryIsConflict",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryIsConflict"
}
#endif
foreign import ccall "ggit_index_entry_ref" ggit_index_entry_ref ::
Ptr IndexEntry ->
IO (Ptr IndexEntry)
indexEntryRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m (Maybe IndexEntry)
indexEntryRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m (Maybe IndexEntry)
indexEntryRef IndexEntry
entry = IO (Maybe IndexEntry) -> m (Maybe IndexEntry)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IndexEntry) -> m (Maybe IndexEntry))
-> IO (Maybe IndexEntry) -> m (Maybe IndexEntry)
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry
result <- Ptr IndexEntry -> IO (Ptr IndexEntry)
ggit_index_entry_ref Ptr IndexEntry
entry'
Maybe IndexEntry
maybeResult <- Ptr IndexEntry
-> (Ptr IndexEntry -> IO IndexEntry) -> IO (Maybe IndexEntry)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr IndexEntry
result ((Ptr IndexEntry -> IO IndexEntry) -> IO (Maybe IndexEntry))
-> (Ptr IndexEntry -> IO IndexEntry) -> IO (Maybe IndexEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr IndexEntry
result' -> do
IndexEntry
result'' <- ((ManagedPtr IndexEntry -> IndexEntry)
-> Ptr IndexEntry -> IO IndexEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr IndexEntry -> IndexEntry
IndexEntry) Ptr IndexEntry
result'
IndexEntry -> IO IndexEntry
forall (m :: * -> *) a. Monad m => a -> m a
return IndexEntry
result''
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Maybe IndexEntry -> IO (Maybe IndexEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IndexEntry
maybeResult
#if defined(ENABLE_OVERLOADING)
data IndexEntryRefMethodInfo
instance (signature ~ (m (Maybe IndexEntry)), MonadIO m) => O.OverloadedMethod IndexEntryRefMethodInfo IndexEntry signature where
overloadedMethod = indexEntryRef
instance O.OverloadedMethodInfo IndexEntryRefMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryRef",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryRef"
}
#endif
foreign import ccall "ggit_index_entry_set_commit" ggit_index_entry_set_commit ::
Ptr IndexEntry ->
Ptr Ggit.Commit.Commit ->
IO ()
indexEntrySetCommit ::
(B.CallStack.HasCallStack, MonadIO m, Ggit.Commit.IsCommit a) =>
IndexEntry
-> a
-> m ()
indexEntrySetCommit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
IndexEntry -> a -> m ()
indexEntrySetCommit IndexEntry
entry a
commit = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr IndexEntry -> Ptr Commit -> IO ()
ggit_index_entry_set_commit Ptr IndexEntry
entry' Ptr Commit
commit'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetCommitMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Ggit.Commit.IsCommit a) => O.OverloadedMethod IndexEntrySetCommitMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetCommit
instance O.OverloadedMethodInfo IndexEntrySetCommitMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetCommit",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetCommit"
}
#endif
foreign import ccall "ggit_index_entry_set_dev" ggit_index_entry_set_dev ::
Ptr IndexEntry ->
Word32 ->
IO ()
indexEntrySetDev ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Word32
-> m ()
indexEntrySetDev :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Word32 -> m ()
indexEntrySetDev IndexEntry
entry Word32
dev = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> Word32 -> IO ()
ggit_index_entry_set_dev Ptr IndexEntry
entry' Word32
dev
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetDevMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetDevMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetDev
instance O.OverloadedMethodInfo IndexEntrySetDevMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetDev",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetDev"
}
#endif
foreign import ccall "ggit_index_entry_set_file_size" ggit_index_entry_set_file_size ::
Ptr IndexEntry ->
Int64 ->
IO ()
indexEntrySetFileSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Int64
-> m ()
indexEntrySetFileSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Int64 -> m ()
indexEntrySetFileSize IndexEntry
entry Int64
fileSize = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> Int64 -> IO ()
ggit_index_entry_set_file_size Ptr IndexEntry
entry' Int64
fileSize
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetFileSizeMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetFileSizeMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetFileSize
instance O.OverloadedMethodInfo IndexEntrySetFileSizeMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetFileSize",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetFileSize"
}
#endif
foreign import ccall "ggit_index_entry_set_flags" ggit_index_entry_set_flags ::
Ptr IndexEntry ->
Word32 ->
IO ()
indexEntrySetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Word32
-> m ()
indexEntrySetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Word32 -> m ()
indexEntrySetFlags IndexEntry
entry Word32
flags = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> Word32 -> IO ()
ggit_index_entry_set_flags Ptr IndexEntry
entry' Word32
flags
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetFlagsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetFlagsMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetFlags
instance O.OverloadedMethodInfo IndexEntrySetFlagsMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetFlags",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetFlags"
}
#endif
foreign import ccall "ggit_index_entry_set_flags_extended" ggit_index_entry_set_flags_extended ::
Ptr IndexEntry ->
Word32 ->
IO ()
indexEntrySetFlagsExtended ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Word32
-> m ()
indexEntrySetFlagsExtended :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Word32 -> m ()
indexEntrySetFlagsExtended IndexEntry
entry Word32
flagsExtended = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> Word32 -> IO ()
ggit_index_entry_set_flags_extended Ptr IndexEntry
entry' Word32
flagsExtended
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetFlagsExtendedMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetFlagsExtendedMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetFlagsExtended
instance O.OverloadedMethodInfo IndexEntrySetFlagsExtendedMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetFlagsExtended",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetFlagsExtended"
}
#endif
foreign import ccall "ggit_index_entry_set_gid" ggit_index_entry_set_gid ::
Ptr IndexEntry ->
Word32 ->
IO ()
indexEntrySetGid ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Word32
-> m ()
indexEntrySetGid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Word32 -> m ()
indexEntrySetGid IndexEntry
entry Word32
gid = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> Word32 -> IO ()
ggit_index_entry_set_gid Ptr IndexEntry
entry' Word32
gid
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetGidMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetGidMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetGid
instance O.OverloadedMethodInfo IndexEntrySetGidMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetGid",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetGid"
}
#endif
foreign import ccall "ggit_index_entry_set_id" ggit_index_entry_set_id ::
Ptr IndexEntry ->
Ptr Ggit.OId.OId ->
IO ()
indexEntrySetId ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Maybe (Ggit.OId.OId)
-> m ()
indexEntrySetId :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Maybe OId -> m ()
indexEntrySetId IndexEntry
entry Maybe OId
id = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr OId
maybeId <- case Maybe OId
id of
Maybe OId
Nothing -> Ptr OId -> IO (Ptr OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr OId
forall a. Ptr a
nullPtr
Just OId
jId -> do
Ptr OId
jId' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
jId
Ptr OId -> IO (Ptr OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr OId
jId'
Ptr IndexEntry -> Ptr OId -> IO ()
ggit_index_entry_set_id Ptr IndexEntry
entry' Ptr OId
maybeId
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
Maybe OId -> (OId -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe OId
id OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetIdMethodInfo
instance (signature ~ (Maybe (Ggit.OId.OId) -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetIdMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetId
instance O.OverloadedMethodInfo IndexEntrySetIdMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetId",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetId"
}
#endif
foreign import ccall "ggit_index_entry_set_ino" ggit_index_entry_set_ino ::
Ptr IndexEntry ->
Word32 ->
IO ()
indexEntrySetIno ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Word32
-> m ()
indexEntrySetIno :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Word32 -> m ()
indexEntrySetIno IndexEntry
entry Word32
ino = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> Word32 -> IO ()
ggit_index_entry_set_ino Ptr IndexEntry
entry' Word32
ino
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetInoMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetInoMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetIno
instance O.OverloadedMethodInfo IndexEntrySetInoMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetIno",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetIno"
}
#endif
foreign import ccall "ggit_index_entry_set_mode" ggit_index_entry_set_mode ::
Ptr IndexEntry ->
Word32 ->
IO ()
indexEntrySetMode ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Word32
-> m ()
indexEntrySetMode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Word32 -> m ()
indexEntrySetMode IndexEntry
entry Word32
mode = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> Word32 -> IO ()
ggit_index_entry_set_mode Ptr IndexEntry
entry' Word32
mode
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetModeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetModeMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetMode
instance O.OverloadedMethodInfo IndexEntrySetModeMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetMode",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetMode"
}
#endif
foreign import ccall "ggit_index_entry_set_path" ggit_index_entry_set_path ::
Ptr IndexEntry ->
CString ->
IO ()
indexEntrySetPath ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Maybe (T.Text)
-> m ()
indexEntrySetPath :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Maybe Text -> m ()
indexEntrySetPath IndexEntry
entry Maybe Text
path = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
CString
maybePath <- case Maybe Text
path of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jPath -> do
CString
jPath' <- Text -> IO CString
textToCString Text
jPath
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jPath'
Ptr IndexEntry -> CString -> IO ()
ggit_index_entry_set_path Ptr IndexEntry
entry' CString
maybePath
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybePath
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetPathMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetPathMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetPath
instance O.OverloadedMethodInfo IndexEntrySetPathMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetPath",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetPath"
}
#endif
foreign import ccall "ggit_index_entry_set_uid" ggit_index_entry_set_uid ::
Ptr IndexEntry ->
Word32 ->
IO ()
indexEntrySetUid ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> Word32
-> m ()
indexEntrySetUid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> Word32 -> m ()
indexEntrySetUid IndexEntry
entry Word32
uid = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> Word32 -> IO ()
ggit_index_entry_set_uid Ptr IndexEntry
entry' Word32
uid
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntrySetUidMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod IndexEntrySetUidMethodInfo IndexEntry signature where
overloadedMethod = indexEntrySetUid
instance O.OverloadedMethodInfo IndexEntrySetUidMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntrySetUid",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntrySetUid"
}
#endif
foreign import ccall "ggit_index_entry_stat" ggit_index_entry_stat ::
Ptr IndexEntry ->
Ptr Gio.File.File ->
Ptr (Ptr GError) ->
IO CInt
indexEntryStat ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) =>
IndexEntry
-> a
-> m ()
indexEntryStat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFile a) =>
IndexEntry -> a -> m ()
indexEntryStat IndexEntry
entry a
file = 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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr File
file' <- a -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
file
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr IndexEntry -> Ptr File -> Ptr (Ptr GError) -> IO CInt
ggit_index_entry_stat Ptr IndexEntry
entry' Ptr File
file'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
file
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data IndexEntryStatMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Gio.File.IsFile a) => O.OverloadedMethod IndexEntryStatMethodInfo IndexEntry signature where
overloadedMethod = indexEntryStat
instance O.OverloadedMethodInfo IndexEntryStatMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryStat",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryStat"
}
#endif
foreign import ccall "ggit_index_entry_unref" ggit_index_entry_unref ::
Ptr IndexEntry ->
IO ()
indexEntryUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntry
-> m ()
indexEntryUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntry -> m ()
indexEntryUnref IndexEntry
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 IndexEntry
entry' <- IndexEntry -> IO (Ptr IndexEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntry
entry
Ptr IndexEntry -> IO ()
ggit_index_entry_unref Ptr IndexEntry
entry'
IndexEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntry
entry
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntryUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod IndexEntryUnrefMethodInfo IndexEntry signature where
overloadedMethod = indexEntryUnref
instance O.OverloadedMethodInfo IndexEntryUnrefMethodInfo IndexEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Structs.IndexEntry.indexEntryUnref",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Structs-IndexEntry.html#v:indexEntryUnref"
}
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveIndexEntryMethod (t :: Symbol) (o :: *) :: * where
ResolveIndexEntryMethod "isConflict" o = IndexEntryIsConflictMethodInfo
ResolveIndexEntryMethod "ref" o = IndexEntryRefMethodInfo
ResolveIndexEntryMethod "stat" o = IndexEntryStatMethodInfo
ResolveIndexEntryMethod "unref" o = IndexEntryUnrefMethodInfo
ResolveIndexEntryMethod "getDev" o = IndexEntryGetDevMethodInfo
ResolveIndexEntryMethod "getFileSize" o = IndexEntryGetFileSizeMethodInfo
ResolveIndexEntryMethod "getFlags" o = IndexEntryGetFlagsMethodInfo
ResolveIndexEntryMethod "getFlagsExtended" o = IndexEntryGetFlagsExtendedMethodInfo
ResolveIndexEntryMethod "getGid" o = IndexEntryGetGidMethodInfo
ResolveIndexEntryMethod "getId" o = IndexEntryGetIdMethodInfo
ResolveIndexEntryMethod "getIno" o = IndexEntryGetInoMethodInfo
ResolveIndexEntryMethod "getMode" o = IndexEntryGetModeMethodInfo
ResolveIndexEntryMethod "getPath" o = IndexEntryGetPathMethodInfo
ResolveIndexEntryMethod "getUid" o = IndexEntryGetUidMethodInfo
ResolveIndexEntryMethod "setCommit" o = IndexEntrySetCommitMethodInfo
ResolveIndexEntryMethod "setDev" o = IndexEntrySetDevMethodInfo
ResolveIndexEntryMethod "setFileSize" o = IndexEntrySetFileSizeMethodInfo
ResolveIndexEntryMethod "setFlags" o = IndexEntrySetFlagsMethodInfo
ResolveIndexEntryMethod "setFlagsExtended" o = IndexEntrySetFlagsExtendedMethodInfo
ResolveIndexEntryMethod "setGid" o = IndexEntrySetGidMethodInfo
ResolveIndexEntryMethod "setId" o = IndexEntrySetIdMethodInfo
ResolveIndexEntryMethod "setIno" o = IndexEntrySetInoMethodInfo
ResolveIndexEntryMethod "setMode" o = IndexEntrySetModeMethodInfo
ResolveIndexEntryMethod "setPath" o = IndexEntrySetPathMethodInfo
ResolveIndexEntryMethod "setUid" o = IndexEntrySetUidMethodInfo
ResolveIndexEntryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveIndexEntryMethod t IndexEntry, O.OverloadedMethod info IndexEntry p) => OL.IsLabel t (IndexEntry -> 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 ~ ResolveIndexEntryMethod t IndexEntry, O.OverloadedMethod info IndexEntry p, R.HasField t IndexEntry p) => R.HasField t IndexEntry p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveIndexEntryMethod t IndexEntry, O.OverloadedMethodInfo info IndexEntry) => OL.IsLabel t (O.MethodProxy info IndexEntry) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif