#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Ggit.Objects.Commit
(
Commit(..) ,
IsCommit ,
toCommit ,
noCommit ,
#if ENABLE_OVERLOADING
CommitAmendMethodInfo ,
#endif
commitAmend ,
#if ENABLE_OVERLOADING
CommitGetAuthorMethodInfo ,
#endif
commitGetAuthor ,
#if ENABLE_OVERLOADING
CommitGetCommitterMethodInfo ,
#endif
commitGetCommitter ,
#if ENABLE_OVERLOADING
CommitGetMessageMethodInfo ,
#endif
commitGetMessage ,
#if ENABLE_OVERLOADING
CommitGetMessageEncodingMethodInfo ,
#endif
commitGetMessageEncoding ,
#if ENABLE_OVERLOADING
CommitGetNthAncestorMethodInfo ,
#endif
commitGetNthAncestor ,
#if ENABLE_OVERLOADING
CommitGetParentsMethodInfo ,
#endif
commitGetParents ,
#if ENABLE_OVERLOADING
CommitGetSubjectMethodInfo ,
#endif
commitGetSubject ,
#if ENABLE_OVERLOADING
CommitGetTreeMethodInfo ,
#endif
commitGetTree ,
#if ENABLE_OVERLOADING
CommitGetTreeIdMethodInfo ,
#endif
commitGetTreeId ,
) 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.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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Ggit.Objects.CommitParents as Ggit.CommitParents
import {-# SOURCE #-} qualified GI.Ggit.Objects.Native as Ggit.Native
import {-# SOURCE #-} qualified GI.Ggit.Objects.Object as Ggit.Object
import {-# SOURCE #-} qualified GI.Ggit.Objects.ObjectFactoryBase as Ggit.ObjectFactoryBase
import {-# SOURCE #-} qualified GI.Ggit.Objects.Signature as Ggit.Signature
import {-# SOURCE #-} qualified GI.Ggit.Objects.Tree as Ggit.Tree
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
newtype Commit = Commit (ManagedPtr Commit)
foreign import ccall "ggit_commit_get_type"
c_ggit_commit_get_type :: IO GType
instance GObject Commit where
gobjectType = c_ggit_commit_get_type
class (GObject o, O.IsDescendantOf Commit o) => IsCommit o
instance (GObject o, O.IsDescendantOf Commit o) => IsCommit o
instance O.HasParentTypes Commit
type instance O.ParentTypes Commit = '[Ggit.Object.Object, Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object]
toCommit :: (MonadIO m, IsCommit o) => o -> m Commit
toCommit = liftIO . unsafeCastTo Commit
noCommit :: Maybe Commit
noCommit = Nothing
#if ENABLE_OVERLOADING
type family ResolveCommitMethod (t :: Symbol) (o :: *) :: * where
ResolveCommitMethod "amend" o = CommitAmendMethodInfo
ResolveCommitMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveCommitMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveCommitMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveCommitMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveCommitMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveCommitMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveCommitMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveCommitMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveCommitMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveCommitMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveCommitMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveCommitMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveCommitMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveCommitMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveCommitMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveCommitMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveCommitMethod "getAuthor" o = CommitGetAuthorMethodInfo
ResolveCommitMethod "getCommitter" o = CommitGetCommitterMethodInfo
ResolveCommitMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveCommitMethod "getId" o = Ggit.Object.ObjectGetIdMethodInfo
ResolveCommitMethod "getMessage" o = CommitGetMessageMethodInfo
ResolveCommitMethod "getMessageEncoding" o = CommitGetMessageEncodingMethodInfo
ResolveCommitMethod "getNthAncestor" o = CommitGetNthAncestorMethodInfo
ResolveCommitMethod "getOwner" o = Ggit.Object.ObjectGetOwnerMethodInfo
ResolveCommitMethod "getParents" o = CommitGetParentsMethodInfo
ResolveCommitMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveCommitMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveCommitMethod "getSubject" o = CommitGetSubjectMethodInfo
ResolveCommitMethod "getTree" o = CommitGetTreeMethodInfo
ResolveCommitMethod "getTreeId" o = CommitGetTreeIdMethodInfo
ResolveCommitMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveCommitMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveCommitMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveCommitMethod t Commit, O.MethodInfo info Commit p) => OL.IsLabel t (Commit -> 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
#if ENABLE_OVERLOADING
instance O.HasAttributeList Commit
type instance O.AttributeList Commit = CommitAttributeList
type CommitAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
#endif
#if ENABLE_OVERLOADING
type instance O.SignalList Commit = CommitSignalList
type CommitSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_commit_amend" ggit_commit_amend ::
Ptr Commit ->
CString ->
Ptr Ggit.Signature.Signature ->
Ptr Ggit.Signature.Signature ->
CString ->
CString ->
Ptr Ggit.Tree.Tree ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.OId.OId)
commitAmend ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c, Ggit.Tree.IsTree d) =>
a
-> Maybe (T.Text)
-> b
-> c
-> Maybe (T.Text)
-> T.Text
-> d
-> m (Maybe Ggit.OId.OId)
commitAmend commit updateRef author committer messageEncoding message tree = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
maybeUpdateRef <- case updateRef of
Nothing -> return nullPtr
Just jUpdateRef -> do
jUpdateRef' <- textToCString jUpdateRef
return jUpdateRef'
author' <- unsafeManagedPtrCastPtr author
committer' <- unsafeManagedPtrCastPtr committer
maybeMessageEncoding <- case messageEncoding of
Nothing -> return nullPtr
Just jMessageEncoding -> do
jMessageEncoding' <- textToCString jMessageEncoding
return jMessageEncoding'
message' <- textToCString message
tree' <- unsafeManagedPtrCastPtr tree
onException (do
result <- propagateGError $ ggit_commit_amend commit' maybeUpdateRef author' committer' maybeMessageEncoding message' tree'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.OId.OId) result'
return result''
touchManagedPtr commit
touchManagedPtr author
touchManagedPtr committer
touchManagedPtr tree
freeMem maybeUpdateRef
freeMem maybeMessageEncoding
freeMem message'
return maybeResult
) (do
freeMem maybeUpdateRef
freeMem maybeMessageEncoding
freeMem message'
)
#if ENABLE_OVERLOADING
data CommitAmendMethodInfo
instance (signature ~ (Maybe (T.Text) -> b -> c -> Maybe (T.Text) -> T.Text -> d -> m (Maybe Ggit.OId.OId)), MonadIO m, IsCommit a, Ggit.Signature.IsSignature b, Ggit.Signature.IsSignature c, Ggit.Tree.IsTree d) => O.MethodInfo CommitAmendMethodInfo a signature where
overloadedMethod _ = commitAmend
#endif
foreign import ccall "ggit_commit_get_author" ggit_commit_get_author ::
Ptr Commit ->
IO (Ptr Ggit.Signature.Signature)
commitGetAuthor ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> m (Maybe Ggit.Signature.Signature)
commitGetAuthor commit = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
result <- ggit_commit_get_author commit'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Ggit.Signature.Signature) result'
return result''
touchManagedPtr commit
return maybeResult
#if ENABLE_OVERLOADING
data CommitGetAuthorMethodInfo
instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetAuthorMethodInfo a signature where
overloadedMethod _ = commitGetAuthor
#endif
foreign import ccall "ggit_commit_get_committer" ggit_commit_get_committer ::
Ptr Commit ->
IO (Ptr Ggit.Signature.Signature)
commitGetCommitter ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> m (Maybe Ggit.Signature.Signature)
commitGetCommitter commit = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
result <- ggit_commit_get_committer commit'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Ggit.Signature.Signature) result'
return result''
touchManagedPtr commit
return maybeResult
#if ENABLE_OVERLOADING
data CommitGetCommitterMethodInfo
instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetCommitterMethodInfo a signature where
overloadedMethod _ = commitGetCommitter
#endif
foreign import ccall "ggit_commit_get_message" ggit_commit_get_message ::
Ptr Commit ->
IO CString
commitGetMessage ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> m (Maybe T.Text)
commitGetMessage commit = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
result <- ggit_commit_get_message commit'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- cstringToText result'
return result''
touchManagedPtr commit
return maybeResult
#if ENABLE_OVERLOADING
data CommitGetMessageMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetMessageMethodInfo a signature where
overloadedMethod _ = commitGetMessage
#endif
foreign import ccall "ggit_commit_get_message_encoding" ggit_commit_get_message_encoding ::
Ptr Commit ->
IO CString
commitGetMessageEncoding ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> m (Maybe T.Text)
commitGetMessageEncoding commit = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
result <- ggit_commit_get_message_encoding commit'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- cstringToText result'
return result''
touchManagedPtr commit
return maybeResult
#if ENABLE_OVERLOADING
data CommitGetMessageEncodingMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetMessageEncodingMethodInfo a signature where
overloadedMethod _ = commitGetMessageEncoding
#endif
foreign import ccall "ggit_commit_get_nth_ancestor" ggit_commit_get_nth_ancestor ::
Ptr Commit ->
Word32 ->
Ptr (Ptr GError) ->
IO (Ptr Commit)
commitGetNthAncestor ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> Word32
-> m (Maybe Commit)
commitGetNthAncestor commit n = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
onException (do
result <- propagateGError $ ggit_commit_get_nth_ancestor commit' n
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Commit) result'
return result''
touchManagedPtr commit
return maybeResult
) (do
return ()
)
#if ENABLE_OVERLOADING
data CommitGetNthAncestorMethodInfo
instance (signature ~ (Word32 -> m (Maybe Commit)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetNthAncestorMethodInfo a signature where
overloadedMethod _ = commitGetNthAncestor
#endif
foreign import ccall "ggit_commit_get_parents" ggit_commit_get_parents ::
Ptr Commit ->
IO (Ptr Ggit.CommitParents.CommitParents)
commitGetParents ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> m (Maybe Ggit.CommitParents.CommitParents)
commitGetParents commit = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
result <- ggit_commit_get_parents commit'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Ggit.CommitParents.CommitParents) result'
return result''
touchManagedPtr commit
return maybeResult
#if ENABLE_OVERLOADING
data CommitGetParentsMethodInfo
instance (signature ~ (m (Maybe Ggit.CommitParents.CommitParents)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetParentsMethodInfo a signature where
overloadedMethod _ = commitGetParents
#endif
foreign import ccall "ggit_commit_get_subject" ggit_commit_get_subject ::
Ptr Commit ->
IO CString
commitGetSubject ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> m (Maybe T.Text)
commitGetSubject commit = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
result <- ggit_commit_get_subject commit'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- cstringToText result'
return result''
touchManagedPtr commit
return maybeResult
#if ENABLE_OVERLOADING
data CommitGetSubjectMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetSubjectMethodInfo a signature where
overloadedMethod _ = commitGetSubject
#endif
foreign import ccall "ggit_commit_get_tree" ggit_commit_get_tree ::
Ptr Commit ->
IO (Ptr Ggit.Tree.Tree)
commitGetTree ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> m (Maybe Ggit.Tree.Tree)
commitGetTree commit = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
result <- ggit_commit_get_tree commit'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Ggit.Tree.Tree) result'
return result''
touchManagedPtr commit
return maybeResult
#if ENABLE_OVERLOADING
data CommitGetTreeMethodInfo
instance (signature ~ (m (Maybe Ggit.Tree.Tree)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetTreeMethodInfo a signature where
overloadedMethod _ = commitGetTree
#endif
foreign import ccall "ggit_commit_get_tree_id" ggit_commit_get_tree_id ::
Ptr Commit ->
IO (Ptr Ggit.OId.OId)
commitGetTreeId ::
(B.CallStack.HasCallStack, MonadIO m, IsCommit a) =>
a
-> m (Maybe Ggit.OId.OId)
commitGetTreeId commit = liftIO $ do
commit' <- unsafeManagedPtrCastPtr commit
result <- ggit_commit_get_tree_id commit'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Ggit.OId.OId) result'
return result''
touchManagedPtr commit
return maybeResult
#if ENABLE_OVERLOADING
data CommitGetTreeIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsCommit a) => O.MethodInfo CommitGetTreeIdMethodInfo a signature where
overloadedMethod _ = commitGetTreeId
#endif