{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Structs.IndexEntries
(
IndexEntries(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveIndexEntriesMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
IndexEntriesGetByIndexMethodInfo ,
#endif
indexEntriesGetByIndex ,
#if defined(ENABLE_OVERLOADING)
IndexEntriesGetByPathMethodInfo ,
#endif
indexEntriesGetByPath ,
#if defined(ENABLE_OVERLOADING)
IndexEntriesRefMethodInfo ,
#endif
indexEntriesRef ,
#if defined(ENABLE_OVERLOADING)
IndexEntriesSizeMethodInfo ,
#endif
indexEntriesSize ,
#if defined(ENABLE_OVERLOADING)
IndexEntriesUnrefMethodInfo ,
#endif
indexEntriesUnref ,
) 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.GHashTable as B.GHT
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.Structs.IndexEntry as Ggit.IndexEntry
import qualified GI.Gio.Interfaces.File as Gio.File
newtype IndexEntries = IndexEntries (SP.ManagedPtr IndexEntries)
deriving (IndexEntries -> IndexEntries -> Bool
(IndexEntries -> IndexEntries -> Bool)
-> (IndexEntries -> IndexEntries -> Bool) -> Eq IndexEntries
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexEntries -> IndexEntries -> Bool
== :: IndexEntries -> IndexEntries -> Bool
$c/= :: IndexEntries -> IndexEntries -> Bool
/= :: IndexEntries -> IndexEntries -> Bool
Eq)
instance SP.ManagedPtrNewtype IndexEntries where
toManagedPtr :: IndexEntries -> ManagedPtr IndexEntries
toManagedPtr (IndexEntries ManagedPtr IndexEntries
p) = ManagedPtr IndexEntries
p
foreign import ccall "ggit_index_entries_get_type" c_ggit_index_entries_get_type ::
IO GType
type instance O.ParentTypes IndexEntries = '[]
instance O.HasParentTypes IndexEntries
instance B.Types.TypedObject IndexEntries where
glibType :: IO GType
glibType = IO GType
c_ggit_index_entries_get_type
instance B.Types.GBoxed IndexEntries
instance B.GValue.IsGValue (Maybe IndexEntries) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_index_entries_get_type
gvalueSet_ :: Ptr GValue -> Maybe IndexEntries -> IO ()
gvalueSet_ Ptr GValue
gv Maybe IndexEntries
P.Nothing = Ptr GValue -> Ptr IndexEntries -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr IndexEntries
forall a. Ptr a
FP.nullPtr :: FP.Ptr IndexEntries)
gvalueSet_ Ptr GValue
gv (P.Just IndexEntries
obj) = IndexEntries -> (Ptr IndexEntries -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr IndexEntries
obj (Ptr GValue -> Ptr IndexEntries -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe IndexEntries)
gvalueGet_ Ptr GValue
gv = do
Ptr IndexEntries
ptr <- Ptr GValue -> IO (Ptr IndexEntries)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr IndexEntries)
if Ptr IndexEntries
ptr Ptr IndexEntries -> Ptr IndexEntries -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr IndexEntries
forall a. Ptr a
FP.nullPtr
then IndexEntries -> Maybe IndexEntries
forall a. a -> Maybe a
P.Just (IndexEntries -> Maybe IndexEntries)
-> IO IndexEntries -> IO (Maybe IndexEntries)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr IndexEntries -> IndexEntries)
-> Ptr IndexEntries -> IO IndexEntries
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr IndexEntries -> IndexEntries
IndexEntries Ptr IndexEntries
ptr
else Maybe IndexEntries -> IO (Maybe IndexEntries)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IndexEntries
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList IndexEntries
type instance O.AttributeList IndexEntries = IndexEntriesAttributeList
type IndexEntriesAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_index_entries_get_by_index" ggit_index_entries_get_by_index ::
Ptr IndexEntries ->
Word64 ->
IO (Ptr Ggit.IndexEntry.IndexEntry)
indexEntriesGetByIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntries
-> Word64
-> m (Maybe Ggit.IndexEntry.IndexEntry)
indexEntriesGetByIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntries -> Word64 -> m (Maybe IndexEntry)
indexEntriesGetByIndex IndexEntries
entries Word64
idx = IO (Maybe IndexEntry) -> m (Maybe IndexEntry)
forall a. IO a -> m a
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 IndexEntries
entries' <- IndexEntries -> IO (Ptr IndexEntries)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntries
entries
Ptr IndexEntry
result <- Ptr IndexEntries -> Word64 -> IO (Ptr IndexEntry)
ggit_index_entries_get_by_index Ptr IndexEntries
entries' Word64
idx
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
wrapBoxed ManagedPtr IndexEntry -> IndexEntry
Ggit.IndexEntry.IndexEntry) Ptr IndexEntry
result'
IndexEntry -> IO IndexEntry
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return IndexEntry
result''
IndexEntries -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntries
entries
Maybe IndexEntry -> IO (Maybe IndexEntry)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IndexEntry
maybeResult
#if defined(ENABLE_OVERLOADING)
data IndexEntriesGetByIndexMethodInfo
instance (signature ~ (Word64 -> m (Maybe Ggit.IndexEntry.IndexEntry)), MonadIO m) => O.OverloadedMethod IndexEntriesGetByIndexMethodInfo IndexEntries signature where
overloadedMethod = indexEntriesGetByIndex
instance O.OverloadedMethodInfo IndexEntriesGetByIndexMethodInfo IndexEntries where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.IndexEntries.indexEntriesGetByIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-IndexEntries.html#v:indexEntriesGetByIndex"
})
#endif
foreign import ccall "ggit_index_entries_get_by_path" ggit_index_entries_get_by_path ::
Ptr IndexEntries ->
Ptr Gio.File.File ->
Int32 ->
IO (Ptr Ggit.IndexEntry.IndexEntry)
indexEntriesGetByPath ::
(B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) =>
IndexEntries
-> a
-> Int32
-> m (Maybe Ggit.IndexEntry.IndexEntry)
indexEntriesGetByPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFile a) =>
IndexEntries -> a -> Int32 -> m (Maybe IndexEntry)
indexEntriesGetByPath IndexEntries
entries a
file Int32
stage = IO (Maybe IndexEntry) -> m (Maybe IndexEntry)
forall a. IO a -> m a
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 IndexEntries
entries' <- IndexEntries -> IO (Ptr IndexEntries)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntries
entries
Ptr File
file' <- a -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
file
Ptr IndexEntry
result <- Ptr IndexEntries -> Ptr File -> Int32 -> IO (Ptr IndexEntry)
ggit_index_entries_get_by_path Ptr IndexEntries
entries' Ptr File
file' Int32
stage
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
wrapBoxed ManagedPtr IndexEntry -> IndexEntry
Ggit.IndexEntry.IndexEntry) Ptr IndexEntry
result'
IndexEntry -> IO IndexEntry
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return IndexEntry
result''
IndexEntries -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntries
entries
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
file
Maybe IndexEntry -> IO (Maybe IndexEntry)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IndexEntry
maybeResult
#if defined(ENABLE_OVERLOADING)
data IndexEntriesGetByPathMethodInfo
instance (signature ~ (a -> Int32 -> m (Maybe Ggit.IndexEntry.IndexEntry)), MonadIO m, Gio.File.IsFile a) => O.OverloadedMethod IndexEntriesGetByPathMethodInfo IndexEntries signature where
overloadedMethod = indexEntriesGetByPath
instance O.OverloadedMethodInfo IndexEntriesGetByPathMethodInfo IndexEntries where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.IndexEntries.indexEntriesGetByPath",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-IndexEntries.html#v:indexEntriesGetByPath"
})
#endif
foreign import ccall "ggit_index_entries_ref" ggit_index_entries_ref ::
Ptr IndexEntries ->
IO (Ptr IndexEntries)
indexEntriesRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntries
-> m (Maybe IndexEntries)
indexEntriesRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntries -> m (Maybe IndexEntries)
indexEntriesRef IndexEntries
entries = IO (Maybe IndexEntries) -> m (Maybe IndexEntries)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IndexEntries) -> m (Maybe IndexEntries))
-> IO (Maybe IndexEntries) -> m (Maybe IndexEntries)
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntries
entries' <- IndexEntries -> IO (Ptr IndexEntries)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntries
entries
Ptr IndexEntries
result <- Ptr IndexEntries -> IO (Ptr IndexEntries)
ggit_index_entries_ref Ptr IndexEntries
entries'
Maybe IndexEntries
maybeResult <- Ptr IndexEntries
-> (Ptr IndexEntries -> IO IndexEntries) -> IO (Maybe IndexEntries)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr IndexEntries
result ((Ptr IndexEntries -> IO IndexEntries) -> IO (Maybe IndexEntries))
-> (Ptr IndexEntries -> IO IndexEntries) -> IO (Maybe IndexEntries)
forall a b. (a -> b) -> a -> b
$ \Ptr IndexEntries
result' -> do
IndexEntries
result'' <- ((ManagedPtr IndexEntries -> IndexEntries)
-> Ptr IndexEntries -> IO IndexEntries
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr IndexEntries -> IndexEntries
IndexEntries) Ptr IndexEntries
result'
IndexEntries -> IO IndexEntries
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return IndexEntries
result''
IndexEntries -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntries
entries
Maybe IndexEntries -> IO (Maybe IndexEntries)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IndexEntries
maybeResult
#if defined(ENABLE_OVERLOADING)
data IndexEntriesRefMethodInfo
instance (signature ~ (m (Maybe IndexEntries)), MonadIO m) => O.OverloadedMethod IndexEntriesRefMethodInfo IndexEntries signature where
overloadedMethod = indexEntriesRef
instance O.OverloadedMethodInfo IndexEntriesRefMethodInfo IndexEntries where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.IndexEntries.indexEntriesRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-IndexEntries.html#v:indexEntriesRef"
})
#endif
foreign import ccall "ggit_index_entries_size" ggit_index_entries_size ::
Ptr IndexEntries ->
IO Word32
indexEntriesSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntries
-> m Word32
indexEntriesSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntries -> m Word32
indexEntriesSize IndexEntries
entries = IO Word32 -> m Word32
forall a. IO a -> m a
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 IndexEntries
entries' <- IndexEntries -> IO (Ptr IndexEntries)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntries
entries
Word32
result <- Ptr IndexEntries -> IO Word32
ggit_index_entries_size Ptr IndexEntries
entries'
IndexEntries -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntries
entries
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data IndexEntriesSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod IndexEntriesSizeMethodInfo IndexEntries signature where
overloadedMethod = indexEntriesSize
instance O.OverloadedMethodInfo IndexEntriesSizeMethodInfo IndexEntries where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.IndexEntries.indexEntriesSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-IndexEntries.html#v:indexEntriesSize"
})
#endif
foreign import ccall "ggit_index_entries_unref" ggit_index_entries_unref ::
Ptr IndexEntries ->
IO ()
indexEntriesUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
IndexEntries
-> m ()
indexEntriesUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
IndexEntries -> m ()
indexEntriesUnref IndexEntries
entries = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr IndexEntries
entries' <- IndexEntries -> IO (Ptr IndexEntries)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr IndexEntries
entries
Ptr IndexEntries -> IO ()
ggit_index_entries_unref Ptr IndexEntries
entries'
IndexEntries -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr IndexEntries
entries
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data IndexEntriesUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod IndexEntriesUnrefMethodInfo IndexEntries signature where
overloadedMethod = indexEntriesUnref
instance O.OverloadedMethodInfo IndexEntriesUnrefMethodInfo IndexEntries where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Structs.IndexEntries.indexEntriesUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.12/docs/GI-Ggit-Structs-IndexEntries.html#v:indexEntriesUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveIndexEntriesMethod (t :: Symbol) (o :: *) :: * where
ResolveIndexEntriesMethod "ref" o = IndexEntriesRefMethodInfo
ResolveIndexEntriesMethod "size" o = IndexEntriesSizeMethodInfo
ResolveIndexEntriesMethod "unref" o = IndexEntriesUnrefMethodInfo
ResolveIndexEntriesMethod "getByIndex" o = IndexEntriesGetByIndexMethodInfo
ResolveIndexEntriesMethod "getByPath" o = IndexEntriesGetByPathMethodInfo
ResolveIndexEntriesMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveIndexEntriesMethod t IndexEntries, O.OverloadedMethod info IndexEntries p) => OL.IsLabel t (IndexEntries -> 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 ~ ResolveIndexEntriesMethod t IndexEntries, O.OverloadedMethod info IndexEntries p, R.HasField t IndexEntries p) => R.HasField t IndexEntries p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveIndexEntriesMethod t IndexEntries, O.OverloadedMethodInfo info IndexEntries) => OL.IsLabel t (O.MethodProxy info IndexEntries) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif