{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.CommitParents
(
CommitParents(..) ,
IsCommitParents ,
toCommitParents ,
#if defined(ENABLE_OVERLOADING)
ResolveCommitParentsMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
CommitParentsGetMethodInfo ,
#endif
commitParentsGet ,
#if defined(ENABLE_OVERLOADING)
CommitParentsGetIdMethodInfo ,
#endif
commitParentsGetId ,
#if defined(ENABLE_OVERLOADING)
CommitParentsGetSizeMethodInfo ,
#endif
commitParentsGetSize ,
commitParentsNew ,
#if defined(ENABLE_OVERLOADING)
CommitParentsCommitPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
commitParentsCommit ,
#endif
constructCommitParentsCommit ,
getCommitParentsCommit ,
#if defined(ENABLE_OVERLOADING)
CommitParentsSizePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
commitParentsSize ,
#endif
getCommitParentsSize ,
) 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.Commit as Ggit.Commit
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
newtype CommitParents = CommitParents (SP.ManagedPtr CommitParents)
deriving (CommitParents -> CommitParents -> Bool
(CommitParents -> CommitParents -> Bool)
-> (CommitParents -> CommitParents -> Bool) -> Eq CommitParents
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommitParents -> CommitParents -> Bool
$c/= :: CommitParents -> CommitParents -> Bool
== :: CommitParents -> CommitParents -> Bool
$c== :: CommitParents -> CommitParents -> Bool
Eq)
instance SP.ManagedPtrNewtype CommitParents where
toManagedPtr :: CommitParents -> ManagedPtr CommitParents
toManagedPtr (CommitParents ManagedPtr CommitParents
p) = ManagedPtr CommitParents
p
foreign import ccall "ggit_commit_parents_get_type"
c_ggit_commit_parents_get_type :: IO B.Types.GType
instance B.Types.TypedObject CommitParents where
glibType :: IO GType
glibType = IO GType
c_ggit_commit_parents_get_type
instance B.Types.GObject CommitParents
class (SP.GObject o, O.IsDescendantOf CommitParents o) => IsCommitParents o
instance (SP.GObject o, O.IsDescendantOf CommitParents o) => IsCommitParents o
instance O.HasParentTypes CommitParents
type instance O.ParentTypes CommitParents = '[GObject.Object.Object]
toCommitParents :: (MIO.MonadIO m, IsCommitParents o) => o -> m CommitParents
toCommitParents :: forall (m :: * -> *) o.
(MonadIO m, IsCommitParents o) =>
o -> m CommitParents
toCommitParents = IO CommitParents -> m CommitParents
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO CommitParents -> m CommitParents)
-> (o -> IO CommitParents) -> o -> m CommitParents
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr CommitParents -> CommitParents)
-> o -> IO CommitParents
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr CommitParents -> CommitParents
CommitParents
instance B.GValue.IsGValue (Maybe CommitParents) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_commit_parents_get_type
gvalueSet_ :: Ptr GValue -> Maybe CommitParents -> IO ()
gvalueSet_ Ptr GValue
gv Maybe CommitParents
P.Nothing = Ptr GValue -> Ptr CommitParents -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr CommitParents
forall a. Ptr a
FP.nullPtr :: FP.Ptr CommitParents)
gvalueSet_ Ptr GValue
gv (P.Just CommitParents
obj) = CommitParents -> (Ptr CommitParents -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CommitParents
obj (Ptr GValue -> Ptr CommitParents -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe CommitParents)
gvalueGet_ Ptr GValue
gv = do
Ptr CommitParents
ptr <- Ptr GValue -> IO (Ptr CommitParents)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr CommitParents)
if Ptr CommitParents
ptr Ptr CommitParents -> Ptr CommitParents -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr CommitParents
forall a. Ptr a
FP.nullPtr
then CommitParents -> Maybe CommitParents
forall a. a -> Maybe a
P.Just (CommitParents -> Maybe CommitParents)
-> IO CommitParents -> IO (Maybe CommitParents)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr CommitParents -> CommitParents)
-> Ptr CommitParents -> IO CommitParents
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr CommitParents -> CommitParents
CommitParents Ptr CommitParents
ptr
else Maybe CommitParents -> IO (Maybe CommitParents)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CommitParents
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveCommitParentsMethod (t :: Symbol) (o :: *) :: * where
ResolveCommitParentsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveCommitParentsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveCommitParentsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveCommitParentsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveCommitParentsMethod "get" o = CommitParentsGetMethodInfo
ResolveCommitParentsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveCommitParentsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveCommitParentsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveCommitParentsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveCommitParentsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveCommitParentsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveCommitParentsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveCommitParentsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveCommitParentsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveCommitParentsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveCommitParentsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveCommitParentsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveCommitParentsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveCommitParentsMethod "getId" o = CommitParentsGetIdMethodInfo
ResolveCommitParentsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveCommitParentsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveCommitParentsMethod "getSize" o = CommitParentsGetSizeMethodInfo
ResolveCommitParentsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveCommitParentsMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveCommitParentsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveCommitParentsMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveCommitParentsMethod t CommitParents, O.OverloadedMethod info CommitParents p) => OL.IsLabel t (CommitParents -> 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 ~ ResolveCommitParentsMethod t CommitParents, O.OverloadedMethod info CommitParents p, R.HasField t CommitParents p) => R.HasField t CommitParents p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveCommitParentsMethod t CommitParents, O.OverloadedMethodInfo info CommitParents) => OL.IsLabel t (O.MethodProxy info CommitParents) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getCommitParentsCommit :: (MonadIO m, IsCommitParents o) => o -> m (Maybe Ggit.Commit.Commit)
getCommitParentsCommit :: forall (m :: * -> *) o.
(MonadIO m, IsCommitParents o) =>
o -> m (Maybe Commit)
getCommitParentsCommit o
obj = IO (Maybe Commit) -> m (Maybe Commit)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Commit) -> m (Maybe Commit))
-> IO (Maybe Commit) -> m (Maybe Commit)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Commit -> Commit) -> IO (Maybe Commit)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"commit" ManagedPtr Commit -> Commit
Ggit.Commit.Commit
constructCommitParentsCommit :: (IsCommitParents o, MIO.MonadIO m, Ggit.Commit.IsCommit a) => a -> m (GValueConstruct o)
constructCommitParentsCommit :: forall o (m :: * -> *) a.
(IsCommitParents o, MonadIO m, IsCommit a) =>
a -> m (GValueConstruct o)
constructCommitParentsCommit a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"commit" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data CommitParentsCommitPropertyInfo
instance AttrInfo CommitParentsCommitPropertyInfo where
type AttrAllowedOps CommitParentsCommitPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint CommitParentsCommitPropertyInfo = IsCommitParents
type AttrSetTypeConstraint CommitParentsCommitPropertyInfo = Ggit.Commit.IsCommit
type AttrTransferTypeConstraint CommitParentsCommitPropertyInfo = Ggit.Commit.IsCommit
type AttrTransferType CommitParentsCommitPropertyInfo = Ggit.Commit.Commit
type AttrGetType CommitParentsCommitPropertyInfo = (Maybe Ggit.Commit.Commit)
type AttrLabel CommitParentsCommitPropertyInfo = "commit"
type AttrOrigin CommitParentsCommitPropertyInfo = CommitParents
attrGet = getCommitParentsCommit
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Ggit.Commit.Commit v
attrConstruct = constructCommitParentsCommit
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.CommitParents.commit"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-CommitParents.html#g:attr:commit"
})
#endif
getCommitParentsSize :: (MonadIO m, IsCommitParents o) => o -> m Word32
getCommitParentsSize :: forall (m :: * -> *) o.
(MonadIO m, IsCommitParents o) =>
o -> m Word32
getCommitParentsSize o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"size"
#if defined(ENABLE_OVERLOADING)
data CommitParentsSizePropertyInfo
instance AttrInfo CommitParentsSizePropertyInfo where
type AttrAllowedOps CommitParentsSizePropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint CommitParentsSizePropertyInfo = IsCommitParents
type AttrSetTypeConstraint CommitParentsSizePropertyInfo = (~) ()
type AttrTransferTypeConstraint CommitParentsSizePropertyInfo = (~) ()
type AttrTransferType CommitParentsSizePropertyInfo = ()
type AttrGetType CommitParentsSizePropertyInfo = Word32
type AttrLabel CommitParentsSizePropertyInfo = "size"
type AttrOrigin CommitParentsSizePropertyInfo = CommitParents
attrGet = getCommitParentsSize
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.CommitParents.size"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-CommitParents.html#g:attr:size"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CommitParents
type instance O.AttributeList CommitParents = CommitParentsAttributeList
type CommitParentsAttributeList = ('[ '("commit", CommitParentsCommitPropertyInfo), '("size", CommitParentsSizePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
commitParentsCommit :: AttrLabelProxy "commit"
commitParentsCommit = AttrLabelProxy
commitParentsSize :: AttrLabelProxy "size"
commitParentsSize = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList CommitParents = CommitParentsSignalList
type CommitParentsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_commit_parents_new" ggit_commit_parents_new ::
Ptr Ggit.Commit.Commit ->
IO (Ptr CommitParents)
commitParentsNew ::
(B.CallStack.HasCallStack, MonadIO m, Ggit.Commit.IsCommit a) =>
a
-> m CommitParents
commitParentsNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommit a) =>
a -> m CommitParents
commitParentsNew a
commit = IO CommitParents -> m CommitParents
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CommitParents -> m CommitParents)
-> IO CommitParents -> m 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_parents_new Ptr Commit
commit'
Text -> Ptr CommitParents -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"commitParentsNew" Ptr CommitParents
result
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
CommitParents) Ptr CommitParents
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
commit
CommitParents -> IO CommitParents
forall (m :: * -> *) a. Monad m => a -> m a
return CommitParents
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ggit_commit_parents_get" ggit_commit_parents_get ::
Ptr CommitParents ->
Word32 ->
IO (Ptr Ggit.Commit.Commit)
commitParentsGet ::
(B.CallStack.HasCallStack, MonadIO m, IsCommitParents a) =>
a
-> Word32
-> m (Maybe Ggit.Commit.Commit)
commitParentsGet :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommitParents a) =>
a -> Word32 -> m (Maybe Commit)
commitParentsGet a
parents Word32
idx = 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 CommitParents
parents' <- a -> IO (Ptr CommitParents)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parents
Ptr Commit
result <- Ptr CommitParents -> Word32 -> IO (Ptr Commit)
ggit_commit_parents_get Ptr CommitParents
parents' Word32
idx
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
Ggit.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
parents
Maybe Commit -> IO (Maybe Commit)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Commit
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitParentsGetMethodInfo
instance (signature ~ (Word32 -> m (Maybe Ggit.Commit.Commit)), MonadIO m, IsCommitParents a) => O.OverloadedMethod CommitParentsGetMethodInfo a signature where
overloadedMethod = commitParentsGet
instance O.OverloadedMethodInfo CommitParentsGetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.CommitParents.commitParentsGet",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-CommitParents.html#v:commitParentsGet"
})
#endif
foreign import ccall "ggit_commit_parents_get_id" ggit_commit_parents_get_id ::
Ptr CommitParents ->
Word32 ->
IO (Ptr Ggit.OId.OId)
commitParentsGetId ::
(B.CallStack.HasCallStack, MonadIO m, IsCommitParents a) =>
a
-> Word32
-> m (Maybe Ggit.OId.OId)
commitParentsGetId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommitParents a) =>
a -> Word32 -> m (Maybe OId)
commitParentsGetId a
parents Word32
idx = 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 CommitParents
parents' <- a -> IO (Ptr CommitParents)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parents
Ptr OId
result <- Ptr CommitParents -> Word32 -> IO (Ptr OId)
ggit_commit_parents_get_id Ptr CommitParents
parents' Word32
idx
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
parents
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
#if defined(ENABLE_OVERLOADING)
data CommitParentsGetIdMethodInfo
instance (signature ~ (Word32 -> m (Maybe Ggit.OId.OId)), MonadIO m, IsCommitParents a) => O.OverloadedMethod CommitParentsGetIdMethodInfo a signature where
overloadedMethod = commitParentsGetId
instance O.OverloadedMethodInfo CommitParentsGetIdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.CommitParents.commitParentsGetId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-CommitParents.html#v:commitParentsGetId"
})
#endif
foreign import ccall "ggit_commit_parents_get_size" ggit_commit_parents_get_size ::
Ptr CommitParents ->
IO Word32
commitParentsGetSize ::
(B.CallStack.HasCallStack, MonadIO m, IsCommitParents a) =>
a
-> m Word32
commitParentsGetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCommitParents a) =>
a -> m Word32
commitParentsGetSize a
parents = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr CommitParents
parents' <- a -> IO (Ptr CommitParents)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parents
Word32
result <- Ptr CommitParents -> IO Word32
ggit_commit_parents_get_size Ptr CommitParents
parents'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parents
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data CommitParentsGetSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsCommitParents a) => O.OverloadedMethod CommitParentsGetSizeMethodInfo a signature where
overloadedMethod = commitParentsGetSize
instance O.OverloadedMethodInfo CommitParentsGetSizeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.CommitParents.commitParentsGetSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-CommitParents.html#v:commitParentsGetSize"
})
#endif