{- |
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 a reflog.
-}

module GI.Ggit.Structs.Reflog
    ( 

-- * Exported types
    Reflog(..)                              ,
    noReflog                                ,


 -- * Methods
-- ** append #method:append#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ReflogAppendMethodInfo                  ,
#endif
    reflogAppend                            ,


-- ** getEntryCount #method:getEntryCount#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ReflogGetEntryCountMethodInfo           ,
#endif
    reflogGetEntryCount                     ,


-- ** getEntryFromIndex #method:getEntryFromIndex#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ReflogGetEntryFromIndexMethodInfo       ,
#endif
    reflogGetEntryFromIndex                 ,


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


-- ** rename #method:rename#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ReflogRenameMethodInfo                  ,
#endif
    reflogRename                            ,


-- ** unref #method:unref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ReflogUnrefMethodInfo                   ,
#endif
    reflogUnref                             ,


-- ** write #method:write#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    ReflogWriteMethodInfo                   ,
#endif
    reflogWrite                             ,




    ) 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.Objects.Signature as Ggit.Signature
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.ReflogEntry as Ggit.ReflogEntry

newtype Reflog = Reflog (ManagedPtr Reflog)
foreign import ccall "ggit_reflog_get_type" c_ggit_reflog_get_type :: 
    IO GType

instance BoxedObject Reflog where
    boxedType _ = c_ggit_reflog_get_type

noReflog :: Maybe Reflog
noReflog = Nothing


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

-- method Reflog::append
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oid", argType = TInterface (Name {namespace = "Ggit", name = "OId"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitOId.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "committer", argType = TInterface (Name {namespace = "Ggit", name = "Signature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitSignature.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ggit_reflog_append" ggit_reflog_append :: 
    Ptr Reflog ->                           -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"})
    Ptr Ggit.OId.OId ->                     -- oid : TInterface (Name {namespace = "Ggit", name = "OId"})
    Ptr Ggit.Signature.Signature ->         -- committer : TInterface (Name {namespace = "Ggit", name = "Signature"})
    CString ->                              -- message : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Creates a reflog entry.
-}
reflogAppend ::
    (B.CallStack.HasCallStack, MonadIO m, Ggit.Signature.IsSignature a) =>
    Reflog
    {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -}
    -> Ggit.OId.OId
    {- ^ /@oid@/: a 'GI.Ggit.Structs.OId.OId'. -}
    -> a
    {- ^ /@committer@/: a 'GI.Ggit.Objects.Signature.Signature'. -}
    -> T.Text
    {- ^ /@message@/: the message. -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
reflogAppend reflog oid committer message = liftIO $ do
    reflog' <- unsafeManagedPtrGetPtr reflog
    oid' <- unsafeManagedPtrGetPtr oid
    committer' <- unsafeManagedPtrCastPtr committer
    message' <- textToCString message
    onException (do
        _ <- propagateGError $ ggit_reflog_append reflog' oid' committer' message'
        touchManagedPtr reflog
        touchManagedPtr oid
        touchManagedPtr committer
        freeMem message'
        return ()
     ) (do
        freeMem message'
     )

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ReflogAppendMethodInfo
instance (signature ~ (Ggit.OId.OId -> a -> T.Text -> m ()), MonadIO m, Ggit.Signature.IsSignature a) => O.MethodInfo ReflogAppendMethodInfo Reflog signature where
    overloadedMethod _ = reflogAppend

#endif

-- method Reflog::get_entry_count
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", 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_reflog_get_entry_count" ggit_reflog_get_entry_count :: 
    Ptr Reflog ->                           -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"})
    IO Word32

{- |
Gets the number of log entries in /@reflog@/.
-}
reflogGetEntryCount ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Reflog
    {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -}
    -> m Word32
    {- ^ __Returns:__ the number of log entries. -}
reflogGetEntryCount reflog = liftIO $ do
    reflog' <- unsafeManagedPtrGetPtr reflog
    result <- ggit_reflog_get_entry_count reflog'
    touchManagedPtr reflog
    return result

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

#endif

-- method Reflog::get_entry_from_index
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position to lookup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Ggit", name = "ReflogEntry"}))
-- throws : False
-- Skip return : False

foreign import ccall "ggit_reflog_get_entry_from_index" ggit_reflog_get_entry_from_index :: 
    Ptr Reflog ->                           -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"})
    Word32 ->                               -- idx : TBasicType TUInt
    IO (Ptr Ggit.ReflogEntry.ReflogEntry)

{- |
Gets the 'GI.Ggit.Structs.ReflogEntry.ReflogEntry' at /@idx@/ in /@reflog@/, or 'Nothing' if not found.
-}
reflogGetEntryFromIndex ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Reflog
    {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -}
    -> Word32
    {- ^ /@idx@/: the position to lookup. -}
    -> m Ggit.ReflogEntry.ReflogEntry
    {- ^ __Returns:__ the reflog entry at the index, or 'Nothing' if not found. -}
reflogGetEntryFromIndex reflog idx = liftIO $ do
    reflog' <- unsafeManagedPtrGetPtr reflog
    result <- ggit_reflog_get_entry_from_index reflog' idx
    checkUnexpectedReturnNULL "reflogGetEntryFromIndex" result
    result' <- (wrapBoxed Ggit.ReflogEntry.ReflogEntry) result
    touchManagedPtr reflog
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ReflogGetEntryFromIndexMethodInfo
instance (signature ~ (Word32 -> m Ggit.ReflogEntry.ReflogEntry), MonadIO m) => O.MethodInfo ReflogGetEntryFromIndexMethodInfo Reflog signature where
    overloadedMethod _ = reflogGetEntryFromIndex

#endif

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

foreign import ccall "ggit_reflog_ref" ggit_reflog_ref :: 
    Ptr Reflog ->                           -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"})
    IO (Ptr Reflog)

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

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

#endif

-- method Reflog::rename
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "reflog", argType = TInterface (Name {namespace = "Ggit", name = "Reflog"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitReflog.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new name of the reference.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ggit_reflog_rename" ggit_reflog_rename :: 
    Ptr Reflog ->                           -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"})
    CString ->                              -- new_name : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Renames the reflog for to /@newName@/, on error /@error@/ is set.
-}
reflogRename ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Reflog
    {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -}
    -> T.Text
    {- ^ /@newName@/: the new name of the reference. -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
reflogRename reflog newName = liftIO $ do
    reflog' <- unsafeManagedPtrGetPtr reflog
    newName' <- textToCString newName
    onException (do
        _ <- propagateGError $ ggit_reflog_rename reflog' newName'
        touchManagedPtr reflog
        freeMem newName'
        return ()
     ) (do
        freeMem newName'
     )

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ReflogRenameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo ReflogRenameMethodInfo Reflog signature where
    overloadedMethod _ = reflogRename

#endif

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

foreign import ccall "ggit_reflog_unref" ggit_reflog_unref :: 
    Ptr Reflog ->                           -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"})
    IO ()

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

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

#endif

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

foreign import ccall "ggit_reflog_write" ggit_reflog_write :: 
    Ptr Reflog ->                           -- reflog : TInterface (Name {namespace = "Ggit", name = "Reflog"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Write the reflog to disk.
-}
reflogWrite ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Reflog
    {- ^ /@reflog@/: a 'GI.Ggit.Structs.Reflog.Reflog'. -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
reflogWrite reflog = liftIO $ do
    reflog' <- unsafeManagedPtrGetPtr reflog
    onException (do
        _ <- propagateGError $ ggit_reflog_write reflog'
        touchManagedPtr reflog
        return ()
     ) (do
        return ()
     )

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

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveReflogMethod (t :: Symbol) (o :: *) :: * where
    ResolveReflogMethod "append" o = ReflogAppendMethodInfo
    ResolveReflogMethod "ref" o = ReflogRefMethodInfo
    ResolveReflogMethod "rename" o = ReflogRenameMethodInfo
    ResolveReflogMethod "unref" o = ReflogUnrefMethodInfo
    ResolveReflogMethod "write" o = ReflogWriteMethodInfo
    ResolveReflogMethod "getEntryCount" o = ReflogGetEntryCountMethodInfo
    ResolveReflogMethod "getEntryFromIndex" o = ReflogGetEntryFromIndexMethodInfo
    ResolveReflogMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveReflogMethod t Reflog, O.MethodInfo info Reflog p) => O.IsLabelProxy t (Reflog -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveReflogMethod t Reflog, O.MethodInfo info Reflog p) => O.IsLabel t (Reflog -> 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