{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

Represents the entries in an index object.
-}

module GI.Ggit.Structs.IndexEntries
    ( 

-- * Exported types
    IndexEntries(..)                        ,
    noIndexEntries                          ,


 -- * Methods
-- ** getByIndex #method:getByIndex#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    IndexEntriesGetByIndexMethodInfo        ,
#endif
    indexEntriesGetByIndex                  ,


-- ** getByPath #method:getByPath#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    IndexEntriesGetByPathMethodInfo         ,
#endif
    indexEntriesGetByPath                   ,


-- ** ref #method:ref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    IndexEntriesRefMethodInfo               ,
#endif
    indexEntriesRef                         ,


-- ** size #method:size#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    IndexEntriesSizeMethodInfo              ,
#endif
    indexEntriesSize                        ,


-- ** unref #method:unref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 {-# SOURCE #-} qualified GI.Ggit.Structs.IndexEntry as Ggit.IndexEntry
import qualified GI.Gio.Interfaces.File as Gio.File

newtype IndexEntries = IndexEntries (ManagedPtr IndexEntries)
foreign import ccall "ggit_index_entries_get_type" c_ggit_index_entries_get_type :: 
    IO GType

instance BoxedObject IndexEntries where
    boxedType _ = c_ggit_index_entries_get_type

noIndexEntries :: Maybe IndexEntries
noIndexEntries = Nothing


#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList IndexEntries
type instance O.AttributeList IndexEntries = IndexEntriesAttributeList
type IndexEntriesAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method IndexEntries::get_by_index
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the entry.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntry"}))
-- throws : False
-- Skip return : False

foreign import ccall "ggit_index_entries_get_by_index" ggit_index_entries_get_by_index :: 
    Ptr IndexEntries ->                     -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"})
    Word64 ->                               -- idx : TBasicType TUInt64
    IO (Ptr Ggit.IndexEntry.IndexEntry)

{- |
Get a 'GI.Ggit.Structs.IndexEntry.IndexEntry' by index. Note that the returned 'GI.Ggit.Structs.IndexEntry.IndexEntry' is
_only_ valid as long as:

1) The associated index has been closed
2) The entry has not been removed (see 'GI.Ggit.Objects.Index.indexRemove')
3) The index has not been refreshed (see 'GI.Ggit.Objects.Index.indexRead')

Changes to the 'GI.Ggit.Structs.IndexEntry.IndexEntry' will be reflected in the index once written
back to disk using 'GI.Ggit.Objects.Index.indexWrite'.
-}
indexEntriesGetByIndex ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    IndexEntries
    {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -}
    -> Word64
    {- ^ /@idx@/: the index of the entry. -}
    -> m Ggit.IndexEntry.IndexEntry
    {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntry.IndexEntry' or 'Nothing' if out of bounds. -}
indexEntriesGetByIndex entries idx = liftIO $ do
    entries' <- unsafeManagedPtrGetPtr entries
    result <- ggit_index_entries_get_by_index entries' idx
    checkUnexpectedReturnNULL "indexEntriesGetByIndex" result
    result' <- (wrapBoxed Ggit.IndexEntry.IndexEntry) result
    touchManagedPtr entries
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data IndexEntriesGetByIndexMethodInfo
instance (signature ~ (Word64 -> m Ggit.IndexEntry.IndexEntry), MonadIO m) => O.MethodInfo IndexEntriesGetByIndexMethodInfo IndexEntries signature where
    overloadedMethod _ = indexEntriesGetByIndex

#endif

-- method IndexEntries::get_by_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path to search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stage", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "stage to search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntry"}))
-- throws : False
-- Skip return : False

foreign import ccall "ggit_index_entries_get_by_path" ggit_index_entries_get_by_path :: 
    Ptr IndexEntries ->                     -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"})
    Ptr Gio.File.File ->                    -- file : TInterface (Name {namespace = "Gio", name = "File"})
    Int32 ->                                -- stage : TBasicType TInt
    IO (Ptr Ggit.IndexEntry.IndexEntry)

{- |
Get a 'GI.Ggit.Structs.IndexEntry.IndexEntry' by index. Note that the returned 'GI.Ggit.Structs.IndexEntry.IndexEntry' is
_only_ valid as long as:

1) The associated index has not been closed
2) The entry has not been removed (see 'GI.Ggit.Objects.Index.indexRemove')
3) The index has not been refreshed (see 'GI.Ggit.Objects.Index.indexRead')

Changes to the 'GI.Ggit.Structs.IndexEntry.IndexEntry' will be reflected in the index once written
back to disk using 'GI.Ggit.Objects.Index.indexWrite'.

/@stage@/ indicates the stage to search the file for. Stages are used in the
index when merge conflicts occur, such that multiple versions of the same
file can be represented in the index. Stage 0 is associated with the working
tree, while stages 1 to 3 are associated with the various versions of the
file in a merge conflict. The special value -1 can be used to match the first
file encountered in any stage.
-}
indexEntriesGetByPath ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) =>
    IndexEntries
    {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -}
    -> a
    {- ^ /@file@/: the path to search. -}
    -> Int32
    {- ^ /@stage@/: stage to search. -}
    -> m Ggit.IndexEntry.IndexEntry
    {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntry.IndexEntry' or 'Nothing' if it was not found. -}
indexEntriesGetByPath entries file stage = liftIO $ do
    entries' <- unsafeManagedPtrGetPtr entries
    file' <- unsafeManagedPtrCastPtr file
    result <- ggit_index_entries_get_by_path entries' file' stage
    checkUnexpectedReturnNULL "indexEntriesGetByPath" result
    result' <- (wrapBoxed Ggit.IndexEntry.IndexEntry) result
    touchManagedPtr entries
    touchManagedPtr file
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data IndexEntriesGetByPathMethodInfo
instance (signature ~ (a -> Int32 -> m Ggit.IndexEntry.IndexEntry), MonadIO m, Gio.File.IsFile a) => O.MethodInfo IndexEntriesGetByPathMethodInfo IndexEntries signature where
    overloadedMethod _ = indexEntriesGetByPath

#endif

-- method IndexEntries::ref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "IndexEntries"}))
-- throws : False
-- Skip return : False

foreign import ccall "ggit_index_entries_ref" ggit_index_entries_ref :: 
    Ptr IndexEntries ->                     -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"})
    IO (Ptr IndexEntries)

{- |
Atomically increments the reference count of /@entries@/ by one.
This function is MT-safe and may be called from any thread.
-}
indexEntriesRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    IndexEntries
    {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -}
    -> m IndexEntries
    {- ^ __Returns:__ a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -}
indexEntriesRef entries = liftIO $ do
    entries' <- unsafeManagedPtrGetPtr entries
    result <- ggit_index_entries_ref entries'
    checkUnexpectedReturnNULL "indexEntriesRef" result
    result' <- (newBoxed IndexEntries) result
    touchManagedPtr entries
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data IndexEntriesRefMethodInfo
instance (signature ~ (m IndexEntries), MonadIO m) => O.MethodInfo IndexEntriesRefMethodInfo IndexEntries signature where
    overloadedMethod _ = indexEntriesRef

#endif

-- method IndexEntries::size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_index_entries_size" ggit_index_entries_size :: 
    Ptr IndexEntries ->                     -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"})
    IO Word32

{- |
Get the number of 'GI.Ggit.Structs.IndexEntry.IndexEntry' entries.
-}
indexEntriesSize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    IndexEntries
    {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -}
    -> m Word32
    {- ^ __Returns:__ the number of entries. -}
indexEntriesSize entries = liftIO $ do
    entries' <- unsafeManagedPtrGetPtr entries
    result <- ggit_index_entries_size entries'
    touchManagedPtr entries
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data IndexEntriesSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo IndexEntriesSizeMethodInfo IndexEntries signature where
    overloadedMethod _ = indexEntriesSize

#endif

-- method IndexEntries::unref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "entries", argType = TInterface (Name {namespace = "Ggit", name = "IndexEntries"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitIndexEntries.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_index_entries_unref" ggit_index_entries_unref :: 
    Ptr IndexEntries ->                     -- entries : TInterface (Name {namespace = "Ggit", name = "IndexEntries"})
    IO ()

{- |
Atomically decrements the reference count of /@entries@/ by one.
If the reference count drops to 0, /@entries@/ is freed.
-}
indexEntriesUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    IndexEntries
    {- ^ /@entries@/: a 'GI.Ggit.Structs.IndexEntries.IndexEntries'. -}
    -> m ()
indexEntriesUnref entries = liftIO $ do
    entries' <- unsafeManagedPtrGetPtr entries
    ggit_index_entries_unref entries'
    touchManagedPtr entries
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data IndexEntriesUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IndexEntriesUnrefMethodInfo IndexEntries signature where
    overloadedMethod _ = indexEntriesUnref

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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.MethodInfo info IndexEntries p) => O.IsLabelProxy t (IndexEntries -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveIndexEntriesMethod t IndexEntries, O.MethodInfo info IndexEntries p) => O.IsLabel t (IndexEntries -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif