{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.Commit
(
Commit(..) ,
IsCommit ,
toCommit ,
#if defined(ENABLE_OVERLOADING)
ResolveCommitMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
CommitAmendMethodInfo ,
#endif
commitAmend ,
#if defined(ENABLE_OVERLOADING)
CommitGetAuthorMethodInfo ,
#endif
commitGetAuthor ,
#if defined(ENABLE_OVERLOADING)
CommitGetCommitterMethodInfo ,
#endif
commitGetCommitter ,
#if defined(ENABLE_OVERLOADING)
CommitGetMessageMethodInfo ,
#endif
commitGetMessage ,
#if defined(ENABLE_OVERLOADING)
CommitGetMessageEncodingMethodInfo ,
#endif
commitGetMessageEncoding ,
#if defined(ENABLE_OVERLOADING)
CommitGetNthAncestorMethodInfo ,
#endif
commitGetNthAncestor ,
#if defined(ENABLE_OVERLOADING)
CommitGetParentsMethodInfo ,
#endif
commitGetParents ,
#if defined(ENABLE_OVERLOADING)
CommitGetSubjectMethodInfo ,
#endif
commitGetSubject ,
#if defined(ENABLE_OVERLOADING)
CommitGetTreeMethodInfo ,
#endif
commitGetTree ,
#if defined(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.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.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 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 (SP.ManagedPtr Commit)
deriving (Commit -> Commit -> Bool
(Commit -> Commit -> Bool)
-> (Commit -> Commit -> Bool) -> Eq Commit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Commit -> Commit -> Bool
$c/= :: Commit -> Commit -> Bool
== :: Commit -> Commit -> Bool
$c== :: Commit -> Commit -> Bool
Eq)
instance SP.ManagedPtrNewtype Commit where
toManagedPtr :: Commit -> ManagedPtr Commit
toManagedPtr (Commit ManagedPtr Commit
p) = ManagedPtr Commit
p
foreign import ccall "ggit_commit_get_type"
c_ggit_commit_get_type :: IO B.Types.GType
instance B.Types.TypedObject Commit where
glibType :: IO GType
glibType = IO GType
c_ggit_commit_get_type
instance B.Types.GObject Commit
class (SP.GObject o, O.IsDescendantOf Commit o) => IsCommit o
instance (SP.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 :: (MIO.MonadIO m, IsCommit o) => o -> m Commit
toCommit :: forall (m :: * -> *) o. (MonadIO m, IsCommit o) => o -> m Commit
toCommit = IO Commit -> m Commit
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Commit -> m Commit) -> (o -> IO Commit) -> o -> m Commit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Commit -> Commit) -> o -> IO Commit
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Commit -> Commit
Commit
instance B.GValue.IsGValue (Maybe Commit) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_commit_get_type
gvalueSet_ :: Ptr GValue -> Maybe Commit -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Commit
P.Nothing = Ptr GValue -> Ptr Commit -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Commit
forall a. Ptr a
FP.nullPtr :: FP.Ptr Commit)
gvalueSet_ Ptr GValue
gv (P.Just Commit
obj) = Commit -> (Ptr Commit -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Commit
obj (Ptr GValue -> Ptr Commit -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Commit)
gvalueGet_ Ptr GValue
gv = do
Ptr Commit
ptr <- Ptr GValue -> IO (Ptr Commit)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Commit)
if Ptr Commit
ptr Ptr Commit -> Ptr Commit -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Commit
forall a. Ptr a
FP.nullPtr
then Commit -> Maybe Commit
forall a. a -> Maybe a
P.Just (Commit -> Maybe Commit) -> IO Commit -> IO (Maybe Commit)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Commit -> Commit) -> Ptr Commit -> IO Commit
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Commit -> Commit
Commit Ptr Commit
ptr
else Maybe Commit -> IO (Maybe Commit)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Commit
forall a. Maybe a
P.Nothing
#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveCommitMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveCommitMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveCommitMethod t Commit, O.OverloadedMethod info Commit p) => OL.IsLabel t (Commit -> 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 ~ ResolveCommitMethod t Commit, O.OverloadedMethod info Commit p, R.HasField t Commit p) => R.HasField t Commit p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveCommitMethod t Commit, O.OverloadedMethodInfo info Commit) => OL.IsLabel t (O.MethodProxy info Commit) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Commit
type instance O.AttributeList Commit = CommitAttributeList
type CommitAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(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 :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsCommit a, IsSignature b, IsSignature c,
IsTree d) =>
a
-> Maybe Text -> b -> c -> Maybe Text -> Text -> d -> m (Maybe OId)
commitAmend a
commit Maybe Text
updateRef b
author c
committer Maybe Text
messageEncoding Text
message d
tree = IO (Maybe OId) -> m (Maybe OId)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe OId) -> m (Maybe OId))
-> IO (Maybe OId) -> m (Maybe OId)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr CChar
maybeUpdateRef <- case Maybe Text
updateRef of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jUpdateRef -> do
Ptr CChar
jUpdateRef' <- Text -> IO (Ptr CChar)
textToCString Text
jUpdateRef
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jUpdateRef'
Ptr Signature
author' <- b -> IO (Ptr Signature)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
author
Ptr Signature
committer' <- c -> IO (Ptr Signature)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
committer
Ptr CChar
maybeMessageEncoding <- case Maybe Text
messageEncoding of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jMessageEncoding -> do
Ptr CChar
jMessageEncoding' <- Text -> IO (Ptr CChar)
textToCString Text
jMessageEncoding
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jMessageEncoding'
Ptr CChar
message' <- Text -> IO (Ptr CChar)
textToCString Text
message
Ptr Tree
tree' <- d -> IO (Ptr Tree)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
tree
IO (Maybe OId) -> IO () -> IO (Maybe OId)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr OId
result <- (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId))
-> (Ptr (Ptr GError) -> IO (Ptr OId)) -> IO (Ptr OId)
forall a b. (a -> b) -> a -> b
$ Ptr Commit
-> Ptr CChar
-> Ptr Signature
-> Ptr Signature
-> Ptr CChar
-> Ptr CChar
-> Ptr Tree
-> Ptr (Ptr GError)
-> IO (Ptr OId)
ggit_commit_amend Ptr Commit
commit' Ptr CChar
maybeUpdateRef Ptr Signature
author' Ptr Signature
committer' Ptr CChar
maybeMessageEncoding Ptr CChar
message' Ptr Tree
tree'
Maybe OId
maybeResult <- Ptr OId -> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr OId
result ((Ptr OId -> IO OId) -> IO (Maybe OId))
-> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. (a -> b) -> a -> b
$ \Ptr OId
result' -> do
OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OId -> OId
Ggit.OId.OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
author
c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
committer
d -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr d
tree
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeUpdateRef
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeMessageEncoding
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
message'
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
) (do
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeUpdateRef
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeMessageEncoding
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
message'
)
#if defined(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.OverloadedMethod CommitAmendMethodInfo a signature where
overloadedMethod = commitAmend
instance O.OverloadedMethodInfo CommitAmendMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitAmend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m (Maybe Signature)
commitGetAuthor a
commit = IO (Maybe Signature) -> m (Maybe Signature)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Signature) -> m (Maybe Signature))
-> IO (Maybe Signature) -> m (Maybe Signature)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr Signature
result <- Ptr Commit -> IO (Ptr Signature)
ggit_commit_get_author Ptr Commit
commit'
Maybe Signature
maybeResult <- Ptr Signature
-> (Ptr Signature -> IO Signature) -> IO (Maybe Signature)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Signature
result ((Ptr Signature -> IO Signature) -> IO (Maybe Signature))
-> (Ptr Signature -> IO Signature) -> IO (Maybe Signature)
forall a b. (a -> b) -> a -> b
$ \Ptr Signature
result' -> do
Signature
result'' <- ((ManagedPtr Signature -> Signature)
-> Ptr Signature -> IO Signature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Signature -> Signature
Ggit.Signature.Signature) Ptr Signature
result'
Signature -> IO Signature
forall (m :: * -> *) a. Monad m => a -> m a
return Signature
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe Signature -> IO (Maybe Signature)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Signature
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitGetAuthorMethodInfo
instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetAuthorMethodInfo a signature where
overloadedMethod = commitGetAuthor
instance O.OverloadedMethodInfo CommitGetAuthorMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetAuthor",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m (Maybe Signature)
commitGetCommitter a
commit = IO (Maybe Signature) -> m (Maybe Signature)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Signature) -> m (Maybe Signature))
-> IO (Maybe Signature) -> m (Maybe Signature)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr Signature
result <- Ptr Commit -> IO (Ptr Signature)
ggit_commit_get_committer Ptr Commit
commit'
Maybe Signature
maybeResult <- Ptr Signature
-> (Ptr Signature -> IO Signature) -> IO (Maybe Signature)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Signature
result ((Ptr Signature -> IO Signature) -> IO (Maybe Signature))
-> (Ptr Signature -> IO Signature) -> IO (Maybe Signature)
forall a b. (a -> b) -> a -> b
$ \Ptr Signature
result' -> do
Signature
result'' <- ((ManagedPtr Signature -> Signature)
-> Ptr Signature -> IO Signature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Signature -> Signature
Ggit.Signature.Signature) Ptr Signature
result'
Signature -> IO Signature
forall (m :: * -> *) a. Monad m => a -> m a
return Signature
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe Signature -> IO (Maybe Signature)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Signature
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitGetCommitterMethodInfo
instance (signature ~ (m (Maybe Ggit.Signature.Signature)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetCommitterMethodInfo a signature where
overloadedMethod = commitGetCommitter
instance O.OverloadedMethodInfo CommitGetCommitterMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetCommitter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m (Maybe Text)
commitGetMessage a
commit = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr CChar
result <- Ptr Commit -> IO (Ptr CChar)
ggit_commit_get_message Ptr Commit
commit'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitGetMessageMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetMessageMethodInfo a signature where
overloadedMethod = commitGetMessage
instance O.OverloadedMethodInfo CommitGetMessageMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetMessage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m (Maybe Text)
commitGetMessageEncoding a
commit = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr CChar
result <- Ptr Commit -> IO (Ptr CChar)
ggit_commit_get_message_encoding Ptr Commit
commit'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitGetMessageEncodingMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetMessageEncodingMethodInfo a signature where
overloadedMethod = commitGetMessageEncoding
instance O.OverloadedMethodInfo CommitGetMessageEncodingMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetMessageEncoding",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> Word32 -> m (Maybe Commit)
commitGetNthAncestor a
commit Word32
n = IO (Maybe Commit) -> m (Maybe Commit)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Commit) -> m (Maybe Commit))
-> IO (Maybe Commit) -> m (Maybe Commit)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
IO (Maybe Commit) -> IO () -> IO (Maybe Commit)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Commit
result <- (Ptr (Ptr GError) -> IO (Ptr Commit)) -> IO (Ptr Commit)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Commit)) -> IO (Ptr Commit))
-> (Ptr (Ptr GError) -> IO (Ptr Commit)) -> IO (Ptr Commit)
forall a b. (a -> b) -> a -> b
$ Ptr Commit -> Word32 -> Ptr (Ptr GError) -> IO (Ptr Commit)
ggit_commit_get_nth_ancestor Ptr Commit
commit' Word32
n
Maybe Commit
maybeResult <- Ptr Commit -> (Ptr Commit -> IO Commit) -> IO (Maybe Commit)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Commit
result ((Ptr Commit -> IO Commit) -> IO (Maybe Commit))
-> (Ptr Commit -> IO Commit) -> IO (Maybe Commit)
forall a b. (a -> b) -> a -> b
$ \Ptr Commit
result' -> do
Commit
result'' <- ((ManagedPtr Commit -> Commit) -> Ptr Commit -> IO Commit
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Commit -> Commit
Commit) Ptr Commit
result'
Commit -> IO Commit
forall (m :: * -> *) a. Monad m => a -> m a
return Commit
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe Commit -> IO (Maybe Commit)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Commit
maybeResult
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data CommitGetNthAncestorMethodInfo
instance (signature ~ (Word32 -> m (Maybe Commit)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetNthAncestorMethodInfo a signature where
overloadedMethod = commitGetNthAncestor
instance O.OverloadedMethodInfo CommitGetNthAncestorMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetNthAncestor",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m (Maybe CommitParents)
commitGetParents a
commit = IO (Maybe CommitParents) -> m (Maybe CommitParents)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe CommitParents) -> m (Maybe CommitParents))
-> IO (Maybe CommitParents) -> m (Maybe CommitParents)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr CommitParents
result <- Ptr Commit -> IO (Ptr CommitParents)
ggit_commit_get_parents Ptr Commit
commit'
Maybe CommitParents
maybeResult <- Ptr CommitParents
-> (Ptr CommitParents -> IO CommitParents)
-> IO (Maybe CommitParents)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CommitParents
result ((Ptr CommitParents -> IO CommitParents)
-> IO (Maybe CommitParents))
-> (Ptr CommitParents -> IO CommitParents)
-> IO (Maybe CommitParents)
forall a b. (a -> b) -> a -> b
$ \Ptr CommitParents
result' -> do
CommitParents
result'' <- ((ManagedPtr CommitParents -> CommitParents)
-> Ptr CommitParents -> IO CommitParents
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr CommitParents -> CommitParents
Ggit.CommitParents.CommitParents) Ptr CommitParents
result'
CommitParents -> IO CommitParents
forall (m :: * -> *) a. Monad m => a -> m a
return CommitParents
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe CommitParents -> IO (Maybe CommitParents)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CommitParents
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitGetParentsMethodInfo
instance (signature ~ (m (Maybe Ggit.CommitParents.CommitParents)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetParentsMethodInfo a signature where
overloadedMethod = commitGetParents
instance O.OverloadedMethodInfo CommitGetParentsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetParents",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m (Maybe Text)
commitGetSubject a
commit = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr CChar
result <- Ptr Commit -> IO (Ptr CChar)
ggit_commit_get_subject Ptr Commit
commit'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitGetSubjectMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetSubjectMethodInfo a signature where
overloadedMethod = commitGetSubject
instance O.OverloadedMethodInfo CommitGetSubjectMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetSubject",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m (Maybe Tree)
commitGetTree a
commit = IO (Maybe Tree) -> m (Maybe Tree)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Tree) -> m (Maybe Tree))
-> IO (Maybe Tree) -> m (Maybe Tree)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr Tree
result <- Ptr Commit -> IO (Ptr Tree)
ggit_commit_get_tree Ptr Commit
commit'
Maybe Tree
maybeResult <- Ptr Tree -> (Ptr Tree -> IO Tree) -> IO (Maybe Tree)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Tree
result ((Ptr Tree -> IO Tree) -> IO (Maybe Tree))
-> (Ptr Tree -> IO Tree) -> IO (Maybe Tree)
forall a b. (a -> b) -> a -> b
$ \Ptr Tree
result' -> do
Tree
result'' <- ((ManagedPtr Tree -> Tree) -> Ptr Tree -> IO Tree
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Tree -> Tree
Ggit.Tree.Tree) Ptr Tree
result'
Tree -> IO Tree
forall (m :: * -> *) a. Monad m => a -> m a
return Tree
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe Tree -> IO (Maybe Tree)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Tree
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitGetTreeMethodInfo
instance (signature ~ (m (Maybe Ggit.Tree.Tree)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetTreeMethodInfo a signature where
overloadedMethod = commitGetTree
instance O.OverloadedMethodInfo CommitGetTreeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetTree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m (Maybe OId)
commitGetTreeId a
commit = IO (Maybe OId) -> m (Maybe OId)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe OId) -> m (Maybe OId))
-> IO (Maybe OId) -> m (Maybe OId)
forall a b. (a -> b) -> a -> b
$ do
Ptr Commit
commit' <- a -> IO (Ptr Commit)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
commit
Ptr OId
result <- Ptr Commit -> IO (Ptr OId)
ggit_commit_get_tree_id Ptr Commit
commit'
Maybe OId
maybeResult <- Ptr OId -> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr OId
result ((Ptr OId -> IO OId) -> IO (Maybe OId))
-> (Ptr OId -> IO OId) -> IO (Maybe OId)
forall a b. (a -> b) -> a -> b
$ \Ptr OId
result' -> do
OId
result'' <- ((ManagedPtr OId -> OId) -> Ptr OId -> IO OId
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr OId -> OId
Ggit.OId.OId) Ptr OId
result'
OId -> IO OId
forall (m :: * -> *) a. Monad m => a -> m a
return OId
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitGetTreeIdMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsCommit a) => O.OverloadedMethod CommitGetTreeIdMethodInfo a signature where
overloadedMethod = commitGetTreeId
instance O.OverloadedMethodInfo CommitGetTreeIdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.Commit.commitGetTreeId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-Commit.html#v:commitGetTreeId"
})
#endif