{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a reflog entry.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Ggit.Structs.ReflogEntry
    (

-- * Exported types
    ReflogEntry(..)                         ,
    noReflogEntry                           ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveReflogEntryMethod                ,
#endif


-- ** getCommitter #method:getCommitter#

#if defined(ENABLE_OVERLOADING)
    ReflogEntryGetCommitterMethodInfo       ,
#endif
    reflogEntryGetCommitter                 ,


-- ** getMessage #method:getMessage#

#if defined(ENABLE_OVERLOADING)
    ReflogEntryGetMessageMethodInfo         ,
#endif
    reflogEntryGetMessage                   ,


-- ** getNewId #method:getNewId#

#if defined(ENABLE_OVERLOADING)
    ReflogEntryGetNewIdMethodInfo           ,
#endif
    reflogEntryGetNewId                     ,


-- ** getOldId #method:getOldId#

#if defined(ENABLE_OVERLOADING)
    ReflogEntryGetOldIdMethodInfo           ,
#endif
    reflogEntryGetOldId                     ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    ReflogEntryRefMethodInfo                ,
#endif
    reflogEntryRef                          ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    ReflogEntryUnrefMethodInfo              ,
#endif
    reflogEntryUnref                        ,




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

-- | Memory-managed wrapper type.
newtype ReflogEntry = ReflogEntry (ManagedPtr ReflogEntry)
    deriving (Eq)
foreign import ccall "ggit_reflog_entry_get_type" c_ggit_reflog_entry_get_type ::
    IO GType

instance BoxedObject ReflogEntry where
    boxedType _ = c_ggit_reflog_entry_get_type

-- | Convert 'ReflogEntry' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue ReflogEntry where
    toGValue o = do
        gtype <- c_ggit_reflog_entry_get_type
        B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_boxed)

    fromGValue gv = do
        ptr <- B.GValue.get_boxed gv :: IO (Ptr ReflogEntry)
        B.ManagedPtr.newBoxed ReflogEntry ptr



-- | A convenience alias for `Nothing` :: `Maybe` `ReflogEntry`.
noReflogEntry :: Maybe ReflogEntry
noReflogEntry = Nothing


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ReflogEntry
type instance O.AttributeList ReflogEntry = ReflogEntryAttributeList
type ReflogEntryAttributeList = ('[ ] :: [(Symbol, *)])
#endif

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

foreign import ccall "ggit_reflog_entry_get_committer" ggit_reflog_entry_get_committer ::
    Ptr ReflogEntry ->                      -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"})
    IO (Ptr Ggit.Signature.Signature)

-- | Gets the committer as a t'GI.Ggit.Objects.Signature.Signature'.
reflogEntryGetCommitter ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ReflogEntry
    -- ^ /@reflogEntry@/: a t'GI.Ggit.Structs.ReflogEntry.ReflogEntry'.
    -> m (Maybe Ggit.Signature.Signature)
    -- ^ __Returns:__ the committer or 'P.Nothing'.
reflogEntryGetCommitter reflogEntry = liftIO $ do
    reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry
    result <- ggit_reflog_entry_get_committer reflogEntry'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Ggit.Signature.Signature) result'
        return result''
    touchManagedPtr reflogEntry
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data ReflogEntryGetCommitterMethodInfo
instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m) => O.MethodInfo ReflogEntryGetCommitterMethodInfo ReflogEntry signature where
    overloadedMethod = reflogEntryGetCommitter

#endif

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

foreign import ccall "ggit_reflog_entry_get_message" ggit_reflog_entry_get_message ::
    Ptr ReflogEntry ->                      -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"})
    IO CString

-- | Gets the message.
reflogEntryGetMessage ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ReflogEntry
    -- ^ /@reflogEntry@/: a t'GI.Ggit.Structs.ReflogEntry.ReflogEntry'.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the message or 'P.Nothing'.
reflogEntryGetMessage reflogEntry = liftIO $ do
    reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry
    result <- ggit_reflog_entry_get_message reflogEntry'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr reflogEntry
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data ReflogEntryGetMessageMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo ReflogEntryGetMessageMethodInfo ReflogEntry signature where
    overloadedMethod = reflogEntryGetMessage

#endif

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

foreign import ccall "ggit_reflog_entry_get_new_id" ggit_reflog_entry_get_new_id ::
    Ptr ReflogEntry ->                      -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"})
    IO (Ptr Ggit.OId.OId)

-- | Gets the new t'GI.Ggit.Structs.OId.OId'.
reflogEntryGetNewId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ReflogEntry
    -- ^ /@reflogEntry@/: a t'GI.Ggit.Structs.ReflogEntry.ReflogEntry'.
    -> m (Maybe Ggit.OId.OId)
    -- ^ __Returns:__ the new oid or 'P.Nothing'.
reflogEntryGetNewId reflogEntry = liftIO $ do
    reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry
    result <- ggit_reflog_entry_get_new_id reflogEntry'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr reflogEntry
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data ReflogEntryGetNewIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo ReflogEntryGetNewIdMethodInfo ReflogEntry signature where
    overloadedMethod = reflogEntryGetNewId

#endif

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

foreign import ccall "ggit_reflog_entry_get_old_id" ggit_reflog_entry_get_old_id ::
    Ptr ReflogEntry ->                      -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"})
    IO (Ptr Ggit.OId.OId)

-- | Gets the old t'GI.Ggit.Structs.OId.OId'.
reflogEntryGetOldId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ReflogEntry
    -- ^ /@reflogEntry@/: a t'GI.Ggit.Structs.ReflogEntry.ReflogEntry'.
    -> m (Maybe Ggit.OId.OId)
    -- ^ __Returns:__ the old oid or 'P.Nothing'.
reflogEntryGetOldId reflogEntry = liftIO $ do
    reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry
    result <- ggit_reflog_entry_get_old_id reflogEntry'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Ggit.OId.OId) result'
        return result''
    touchManagedPtr reflogEntry
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data ReflogEntryGetOldIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m) => O.MethodInfo ReflogEntryGetOldIdMethodInfo ReflogEntry signature where
    overloadedMethod = reflogEntryGetOldId

#endif

-- method ReflogEntry::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "reflog_entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "ReflogEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitReflogEntry."
--                 , 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_entry_ref" ggit_reflog_entry_ref ::
    Ptr ReflogEntry ->                      -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"})
    IO (Ptr ReflogEntry)

-- | Atomically increments the reference count of /@reflogEntry@/ by one.
-- This function is MT-safe and may be called from any thread.
reflogEntryRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ReflogEntry
    -- ^ /@reflogEntry@/: a t'GI.Ggit.Structs.ReflogEntry.ReflogEntry'.
    -> m (Maybe ReflogEntry)
    -- ^ __Returns:__ the passed in t'GI.Ggit.Structs.ReflogEntry.ReflogEntry' or 'P.Nothing'.
reflogEntryRef reflogEntry = liftIO $ do
    reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry
    result <- ggit_reflog_entry_ref reflogEntry'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed ReflogEntry) result'
        return result''
    touchManagedPtr reflogEntry
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data ReflogEntryRefMethodInfo
instance (signature ~ (m (Maybe ReflogEntry)), MonadIO m) => O.MethodInfo ReflogEntryRefMethodInfo ReflogEntry signature where
    overloadedMethod = reflogEntryRef

#endif

-- method ReflogEntry::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "reflog_entry"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "ReflogEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitReflogEntry."
--                 , 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_entry_unref" ggit_reflog_entry_unref ::
    Ptr ReflogEntry ->                      -- reflog_entry : TInterface (Name {namespace = "Ggit", name = "ReflogEntry"})
    IO ()

-- | Atomically decrements the reference count of /@reflogEntry@/ by one.
-- If the reference count drops to 0, /@reflogEntry@/ is freed.
reflogEntryUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ReflogEntry
    -- ^ /@reflogEntry@/: a t'GI.Ggit.Structs.ReflogEntry.ReflogEntry'.
    -> m ()
reflogEntryUnref reflogEntry = liftIO $ do
    reflogEntry' <- unsafeManagedPtrGetPtr reflogEntry
    ggit_reflog_entry_unref reflogEntry'
    touchManagedPtr reflogEntry
    return ()

#if defined(ENABLE_OVERLOADING)
data ReflogEntryUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ReflogEntryUnrefMethodInfo ReflogEntry signature where
    overloadedMethod = reflogEntryUnref

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveReflogEntryMethod (t :: Symbol) (o :: *) :: * where
    ResolveReflogEntryMethod "ref" o = ReflogEntryRefMethodInfo
    ResolveReflogEntryMethod "unref" o = ReflogEntryUnrefMethodInfo
    ResolveReflogEntryMethod "getCommitter" o = ReflogEntryGetCommitterMethodInfo
    ResolveReflogEntryMethod "getMessage" o = ReflogEntryGetMessageMethodInfo
    ResolveReflogEntryMethod "getNewId" o = ReflogEntryGetNewIdMethodInfo
    ResolveReflogEntryMethod "getOldId" o = ReflogEntryGetOldIdMethodInfo
    ResolveReflogEntryMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveReflogEntryMethod t ReflogEntry, O.MethodInfo info ReflogEntry p) => OL.IsLabel t (ReflogEntry -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif