{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.Ref
(
Ref(..) ,
IsRef ,
toRef ,
#if defined(ENABLE_OVERLOADING)
ResolveRefMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RefDeleteMethodInfo ,
#endif
refDelete ,
#if defined(ENABLE_OVERLOADING)
RefDeleteLogMethodInfo ,
#endif
refDeleteLog ,
#if defined(ENABLE_OVERLOADING)
RefGetLogMethodInfo ,
#endif
refGetLog ,
#if defined(ENABLE_OVERLOADING)
RefGetNameMethodInfo ,
#endif
refGetName ,
#if defined(ENABLE_OVERLOADING)
RefGetOwnerMethodInfo ,
#endif
refGetOwner ,
#if defined(ENABLE_OVERLOADING)
RefGetReferenceTypeMethodInfo ,
#endif
refGetReferenceType ,
#if defined(ENABLE_OVERLOADING)
RefGetShorthandMethodInfo ,
#endif
refGetShorthand ,
#if defined(ENABLE_OVERLOADING)
RefGetSymbolicTargetMethodInfo ,
#endif
refGetSymbolicTarget ,
#if defined(ENABLE_OVERLOADING)
RefGetTargetMethodInfo ,
#endif
refGetTarget ,
#if defined(ENABLE_OVERLOADING)
RefHasLogMethodInfo ,
#endif
refHasLog ,
#if defined(ENABLE_OVERLOADING)
RefIsBranchMethodInfo ,
#endif
refIsBranch ,
#if defined(ENABLE_OVERLOADING)
RefIsNoteMethodInfo ,
#endif
refIsNote ,
#if defined(ENABLE_OVERLOADING)
RefIsRemoteMethodInfo ,
#endif
refIsRemote ,
#if defined(ENABLE_OVERLOADING)
RefIsTagMethodInfo ,
#endif
refIsTag ,
refIsValidName ,
#if defined(ENABLE_OVERLOADING)
RefLookupMethodInfo ,
#endif
refLookup ,
#if defined(ENABLE_OVERLOADING)
RefRenameMethodInfo ,
#endif
refRename ,
#if defined(ENABLE_OVERLOADING)
RefResolveMethodInfo ,
#endif
refResolve ,
#if defined(ENABLE_OVERLOADING)
RefSetSymbolicTargetMethodInfo ,
#endif
refSetSymbolicTarget ,
#if defined(ENABLE_OVERLOADING)
RefSetTargetMethodInfo ,
#endif
refSetTarget ,
#if defined(ENABLE_OVERLOADING)
RefToStringMethodInfo ,
#endif
refToString ,
) 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.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.Enums as Ggit.Enums
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.Repository as Ggit.Repository
import {-# SOURCE #-} qualified GI.Ggit.Structs.OId as Ggit.OId
import {-# SOURCE #-} qualified GI.Ggit.Structs.Reflog as Ggit.Reflog
newtype Ref = Ref (SP.ManagedPtr Ref)
deriving (Ref -> Ref -> Bool
(Ref -> Ref -> Bool) -> (Ref -> Ref -> Bool) -> Eq Ref
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ref -> Ref -> Bool
$c/= :: Ref -> Ref -> Bool
== :: Ref -> Ref -> Bool
$c== :: Ref -> Ref -> Bool
Eq)
instance SP.ManagedPtrNewtype Ref where
toManagedPtr :: Ref -> ManagedPtr Ref
toManagedPtr (Ref ManagedPtr Ref
p) = ManagedPtr Ref
p
foreign import ccall "ggit_ref_get_type"
c_ggit_ref_get_type :: IO B.Types.GType
instance B.Types.TypedObject Ref where
glibType :: IO GType
glibType = IO GType
c_ggit_ref_get_type
instance B.Types.GObject Ref
class (SP.GObject o, O.IsDescendantOf Ref o) => IsRef o
instance (SP.GObject o, O.IsDescendantOf Ref o) => IsRef o
instance O.HasParentTypes Ref
type instance O.ParentTypes Ref = '[Ggit.Native.Native, Ggit.ObjectFactoryBase.ObjectFactoryBase, GObject.Object.Object]
toRef :: (MIO.MonadIO m, IsRef o) => o -> m Ref
toRef :: forall (m :: * -> *) o. (MonadIO m, IsRef o) => o -> m Ref
toRef = IO Ref -> m Ref
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Ref -> m Ref) -> (o -> IO Ref) -> o -> m Ref
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Ref -> Ref) -> o -> IO Ref
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Ref -> Ref
Ref
instance B.GValue.IsGValue (Maybe Ref) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_ref_get_type
gvalueSet_ :: Ptr GValue -> Maybe Ref -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Ref
P.Nothing = Ptr GValue -> Ptr Ref -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Ref
forall a. Ptr a
FP.nullPtr :: FP.Ptr Ref)
gvalueSet_ Ptr GValue
gv (P.Just Ref
obj) = Ref -> (Ptr Ref -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Ref
obj (Ptr GValue -> Ptr Ref -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Ref)
gvalueGet_ Ptr GValue
gv = do
Ptr Ref
ptr <- Ptr GValue -> IO (Ptr Ref)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Ref)
if Ptr Ref
ptr Ptr Ref -> Ptr Ref -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Ref
forall a. Ptr a
FP.nullPtr
then Ref -> Maybe Ref
forall a. a -> Maybe a
P.Just (Ref -> Maybe Ref) -> IO Ref -> IO (Maybe Ref)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Ref -> Ref) -> Ptr Ref -> IO Ref
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Ref -> Ref
Ref Ptr Ref
ptr
else Maybe Ref -> IO (Maybe Ref)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Ref
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveRefMethod (t :: Symbol) (o :: *) :: * where
ResolveRefMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveRefMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveRefMethod "delete" o = RefDeleteMethodInfo
ResolveRefMethod "deleteLog" o = RefDeleteLogMethodInfo
ResolveRefMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveRefMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveRefMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveRefMethod "hasLog" o = RefHasLogMethodInfo
ResolveRefMethod "isBranch" o = RefIsBranchMethodInfo
ResolveRefMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveRefMethod "isNote" o = RefIsNoteMethodInfo
ResolveRefMethod "isRemote" o = RefIsRemoteMethodInfo
ResolveRefMethod "isTag" o = RefIsTagMethodInfo
ResolveRefMethod "lookup" o = RefLookupMethodInfo
ResolveRefMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveRefMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveRefMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveRefMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveRefMethod "rename" o = RefRenameMethodInfo
ResolveRefMethod "resolve" o = RefResolveMethodInfo
ResolveRefMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveRefMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveRefMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveRefMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveRefMethod "toString" o = RefToStringMethodInfo
ResolveRefMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveRefMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveRefMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveRefMethod "getLog" o = RefGetLogMethodInfo
ResolveRefMethod "getName" o = RefGetNameMethodInfo
ResolveRefMethod "getOwner" o = RefGetOwnerMethodInfo
ResolveRefMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveRefMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveRefMethod "getReferenceType" o = RefGetReferenceTypeMethodInfo
ResolveRefMethod "getShorthand" o = RefGetShorthandMethodInfo
ResolveRefMethod "getSymbolicTarget" o = RefGetSymbolicTargetMethodInfo
ResolveRefMethod "getTarget" o = RefGetTargetMethodInfo
ResolveRefMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveRefMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveRefMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveRefMethod "setSymbolicTarget" o = RefSetSymbolicTargetMethodInfo
ResolveRefMethod "setTarget" o = RefSetTargetMethodInfo
ResolveRefMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRefMethod t Ref, O.OverloadedMethod info Ref p) => OL.IsLabel t (Ref -> 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 ~ ResolveRefMethod t Ref, O.OverloadedMethod info Ref p, R.HasField t Ref p) => R.HasField t Ref p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRefMethod t Ref, O.OverloadedMethodInfo info Ref) => OL.IsLabel t (O.MethodProxy info Ref) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Ref
type instance O.AttributeList Ref = RefAttributeList
type RefAttributeList = ('[ '("native", Ggit.Native.NativeNativePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Ref = RefSignalList
type RefSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_ref_delete" ggit_ref_delete ::
Ptr Ref ->
Ptr (Ptr GError) ->
IO ()
refDelete ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m ()
refDelete :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m ()
refDelete a
ref = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
(Ptr (Ptr GError) -> IO ()) -> IO ()
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO ()) -> IO ())
-> (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Ref -> Ptr (Ptr GError) -> IO ()
ggit_ref_delete Ptr Ref
ref'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data RefDeleteMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRef a) => O.OverloadedMethod RefDeleteMethodInfo a signature where
overloadedMethod = refDelete
instance O.OverloadedMethodInfo RefDeleteMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refDelete",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refDelete"
}
#endif
foreign import ccall "ggit_ref_delete_log" ggit_ref_delete_log ::
Ptr Ref ->
Ptr (Ptr GError) ->
IO ()
refDeleteLog ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m ()
refDeleteLog :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m ()
refDeleteLog a
ref = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
(Ptr (Ptr GError) -> IO ()) -> IO ()
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO ()) -> IO ())
-> (Ptr (Ptr GError) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Ref -> Ptr (Ptr GError) -> IO ()
ggit_ref_delete_log Ptr Ref
ref'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data RefDeleteLogMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRef a) => O.OverloadedMethod RefDeleteLogMethodInfo a signature where
overloadedMethod = refDeleteLog
instance O.OverloadedMethodInfo RefDeleteLogMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refDeleteLog",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refDeleteLog"
}
#endif
foreign import ccall "ggit_ref_get_log" ggit_ref_get_log ::
Ptr Ref ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.Reflog.Reflog)
refGetLog ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe Ggit.Reflog.Reflog)
refGetLog :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe Reflog)
refGetLog a
ref = IO (Maybe Reflog) -> m (Maybe Reflog)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Reflog) -> m (Maybe Reflog))
-> IO (Maybe Reflog) -> m (Maybe Reflog)
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
IO (Maybe Reflog) -> IO () -> IO (Maybe Reflog)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Reflog
result <- (Ptr (Ptr GError) -> IO (Ptr Reflog)) -> IO (Ptr Reflog)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Reflog)) -> IO (Ptr Reflog))
-> (Ptr (Ptr GError) -> IO (Ptr Reflog)) -> IO (Ptr Reflog)
forall a b. (a -> b) -> a -> b
$ Ptr Ref -> Ptr (Ptr GError) -> IO (Ptr Reflog)
ggit_ref_get_log Ptr Ref
ref'
Maybe Reflog
maybeResult <- Ptr Reflog -> (Ptr Reflog -> IO Reflog) -> IO (Maybe Reflog)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Reflog
result ((Ptr Reflog -> IO Reflog) -> IO (Maybe Reflog))
-> (Ptr Reflog -> IO Reflog) -> IO (Maybe Reflog)
forall a b. (a -> b) -> a -> b
$ \Ptr Reflog
result' -> do
Reflog
result'' <- ((ManagedPtr Reflog -> Reflog) -> Ptr Reflog -> IO Reflog
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Reflog -> Reflog
Ggit.Reflog.Reflog) Ptr Reflog
result'
Reflog -> IO Reflog
forall (m :: * -> *) a. Monad m => a -> m a
return Reflog
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Maybe Reflog -> IO (Maybe Reflog)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Reflog
maybeResult
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data RefGetLogMethodInfo
instance (signature ~ (m (Maybe Ggit.Reflog.Reflog)), MonadIO m, IsRef a) => O.OverloadedMethod RefGetLogMethodInfo a signature where
overloadedMethod = refGetLog
instance O.OverloadedMethodInfo RefGetLogMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refGetLog",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refGetLog"
}
#endif
foreign import ccall "ggit_ref_get_name" ggit_ref_get_name ::
Ptr Ref ->
IO CString
refGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe T.Text)
refGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe Text)
refGetName a
ref = 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 Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CString
result <- Ptr Ref -> IO CString
ggit_ref_get_name Ptr Ref
ref'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
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
ref
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data RefGetNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRef a) => O.OverloadedMethod RefGetNameMethodInfo a signature where
overloadedMethod = refGetName
instance O.OverloadedMethodInfo RefGetNameMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refGetName",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refGetName"
}
#endif
foreign import ccall "ggit_ref_get_owner" ggit_ref_get_owner ::
Ptr Ref ->
IO (Ptr Ggit.Repository.Repository)
refGetOwner ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe Ggit.Repository.Repository)
refGetOwner :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe Repository)
refGetOwner a
ref = IO (Maybe Repository) -> m (Maybe Repository)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Repository) -> m (Maybe Repository))
-> IO (Maybe Repository) -> m (Maybe Repository)
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
Ptr Repository
result <- Ptr Ref -> IO (Ptr Repository)
ggit_ref_get_owner Ptr Ref
ref'
Maybe Repository
maybeResult <- Ptr Repository
-> (Ptr Repository -> IO Repository) -> IO (Maybe Repository)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Repository
result ((Ptr Repository -> IO Repository) -> IO (Maybe Repository))
-> (Ptr Repository -> IO Repository) -> IO (Maybe Repository)
forall a b. (a -> b) -> a -> b
$ \Ptr Repository
result' -> do
Repository
result'' <- ((ManagedPtr Repository -> Repository)
-> Ptr Repository -> IO Repository
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Repository -> Repository
Ggit.Repository.Repository) Ptr Repository
result'
Repository -> IO Repository
forall (m :: * -> *) a. Monad m => a -> m a
return Repository
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Maybe Repository -> IO (Maybe Repository)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Repository
maybeResult
#if defined(ENABLE_OVERLOADING)
data RefGetOwnerMethodInfo
instance (signature ~ (m (Maybe Ggit.Repository.Repository)), MonadIO m, IsRef a) => O.OverloadedMethod RefGetOwnerMethodInfo a signature where
overloadedMethod = refGetOwner
instance O.OverloadedMethodInfo RefGetOwnerMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refGetOwner",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refGetOwner"
}
#endif
foreign import ccall "ggit_ref_get_reference_type" ggit_ref_get_reference_type ::
Ptr Ref ->
IO CUInt
refGetReferenceType ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m Ggit.Enums.RefType
refGetReferenceType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m RefType
refGetReferenceType a
ref = IO RefType -> m RefType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RefType -> m RefType) -> IO RefType -> m RefType
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CUInt
result <- Ptr Ref -> IO CUInt
ggit_ref_get_reference_type Ptr Ref
ref'
let result' :: RefType
result' = (Int -> RefType
forall a. Enum a => Int -> a
toEnum (Int -> RefType) -> (CUInt -> Int) -> CUInt -> RefType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
RefType -> IO RefType
forall (m :: * -> *) a. Monad m => a -> m a
return RefType
result'
#if defined(ENABLE_OVERLOADING)
data RefGetReferenceTypeMethodInfo
instance (signature ~ (m Ggit.Enums.RefType), MonadIO m, IsRef a) => O.OverloadedMethod RefGetReferenceTypeMethodInfo a signature where
overloadedMethod = refGetReferenceType
instance O.OverloadedMethodInfo RefGetReferenceTypeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refGetReferenceType",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refGetReferenceType"
}
#endif
foreign import ccall "ggit_ref_get_shorthand" ggit_ref_get_shorthand ::
Ptr Ref ->
IO CString
refGetShorthand ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe T.Text)
refGetShorthand :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe Text)
refGetShorthand a
ref = 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 Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CString
result <- Ptr Ref -> IO CString
ggit_ref_get_shorthand Ptr Ref
ref'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
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
ref
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data RefGetShorthandMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRef a) => O.OverloadedMethod RefGetShorthandMethodInfo a signature where
overloadedMethod = refGetShorthand
instance O.OverloadedMethodInfo RefGetShorthandMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refGetShorthand",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refGetShorthand"
}
#endif
foreign import ccall "ggit_ref_get_symbolic_target" ggit_ref_get_symbolic_target ::
Ptr Ref ->
IO CString
refGetSymbolicTarget ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe T.Text)
refGetSymbolicTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe Text)
refGetSymbolicTarget a
ref = 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 Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CString
result <- Ptr Ref -> IO CString
ggit_ref_get_symbolic_target Ptr Ref
ref'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
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
ref
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data RefGetSymbolicTargetMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRef a) => O.OverloadedMethod RefGetSymbolicTargetMethodInfo a signature where
overloadedMethod = refGetSymbolicTarget
instance O.OverloadedMethodInfo RefGetSymbolicTargetMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refGetSymbolicTarget",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refGetSymbolicTarget"
}
#endif
foreign import ccall "ggit_ref_get_target" ggit_ref_get_target ::
Ptr Ref ->
IO (Ptr Ggit.OId.OId)
refGetTarget ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe Ggit.OId.OId)
refGetTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe OId)
refGetTarget a
ref = 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 Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
Ptr OId
result <- Ptr Ref -> IO (Ptr OId)
ggit_ref_get_target Ptr Ref
ref'
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
ref
Maybe OId -> IO (Maybe OId)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe OId
maybeResult
#if defined(ENABLE_OVERLOADING)
data RefGetTargetMethodInfo
instance (signature ~ (m (Maybe Ggit.OId.OId)), MonadIO m, IsRef a) => O.OverloadedMethod RefGetTargetMethodInfo a signature where
overloadedMethod = refGetTarget
instance O.OverloadedMethodInfo RefGetTargetMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refGetTarget",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refGetTarget"
}
#endif
foreign import ccall "ggit_ref_has_log" ggit_ref_has_log ::
Ptr Ref ->
IO CInt
refHasLog ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m Bool
refHasLog :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m Bool
refHasLog a
ref = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CInt
result <- Ptr Ref -> IO CInt
ggit_ref_has_log Ptr Ref
ref'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RefHasLogMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.OverloadedMethod RefHasLogMethodInfo a signature where
overloadedMethod = refHasLog
instance O.OverloadedMethodInfo RefHasLogMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refHasLog",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refHasLog"
}
#endif
foreign import ccall "ggit_ref_is_branch" ggit_ref_is_branch ::
Ptr Ref ->
IO CInt
refIsBranch ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m Bool
refIsBranch :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m Bool
refIsBranch a
ref = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CInt
result <- Ptr Ref -> IO CInt
ggit_ref_is_branch Ptr Ref
ref'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RefIsBranchMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.OverloadedMethod RefIsBranchMethodInfo a signature where
overloadedMethod = refIsBranch
instance O.OverloadedMethodInfo RefIsBranchMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refIsBranch",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refIsBranch"
}
#endif
foreign import ccall "ggit_ref_is_note" ggit_ref_is_note ::
Ptr Ref ->
IO CInt
refIsNote ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m Bool
refIsNote :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m Bool
refIsNote a
ref = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CInt
result <- Ptr Ref -> IO CInt
ggit_ref_is_note Ptr Ref
ref'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RefIsNoteMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.OverloadedMethod RefIsNoteMethodInfo a signature where
overloadedMethod = refIsNote
instance O.OverloadedMethodInfo RefIsNoteMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refIsNote",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refIsNote"
}
#endif
foreign import ccall "ggit_ref_is_remote" ggit_ref_is_remote ::
Ptr Ref ->
IO CInt
refIsRemote ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m Bool
refIsRemote :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m Bool
refIsRemote a
ref = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CInt
result <- Ptr Ref -> IO CInt
ggit_ref_is_remote Ptr Ref
ref'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RefIsRemoteMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.OverloadedMethod RefIsRemoteMethodInfo a signature where
overloadedMethod = refIsRemote
instance O.OverloadedMethodInfo RefIsRemoteMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refIsRemote",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refIsRemote"
}
#endif
foreign import ccall "ggit_ref_is_tag" ggit_ref_is_tag ::
Ptr Ref ->
IO CInt
refIsTag ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m Bool
refIsTag :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m Bool
refIsTag a
ref = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CInt
result <- Ptr Ref -> IO CInt
ggit_ref_is_tag Ptr Ref
ref'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RefIsTagMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsRef a) => O.OverloadedMethod RefIsTagMethodInfo a signature where
overloadedMethod = refIsTag
instance O.OverloadedMethodInfo RefIsTagMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refIsTag",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refIsTag"
}
#endif
foreign import ccall "ggit_ref_lookup" ggit_ref_lookup ::
Ptr Ref ->
Ptr (Ptr GError) ->
IO (Ptr Ggit.Object.Object)
refLookup ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe Ggit.Object.Object)
refLookup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe Object)
refLookup a
ref = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
IO (Maybe Object) -> IO () -> IO (Maybe Object)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Object
result <- (Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object))
-> (Ptr (Ptr GError) -> IO (Ptr Object)) -> IO (Ptr Object)
forall a b. (a -> b) -> a -> b
$ Ptr Ref -> Ptr (Ptr GError) -> IO (Ptr Object)
ggit_ref_lookup Ptr Ref
ref'
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
Ggit.Object.Object) Ptr Object
result'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data RefLookupMethodInfo
instance (signature ~ (m (Maybe Ggit.Object.Object)), MonadIO m, IsRef a) => O.OverloadedMethod RefLookupMethodInfo a signature where
overloadedMethod = refLookup
instance O.OverloadedMethodInfo RefLookupMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refLookup",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refLookup"
}
#endif
foreign import ccall "ggit_ref_rename" ggit_ref_rename ::
Ptr Ref ->
CString ->
CInt ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr Ref)
refRename ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> T.Text
-> Bool
-> T.Text
-> m (Maybe Ref)
refRename :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> Text -> Bool -> Text -> m (Maybe Ref)
refRename a
ref Text
newName Bool
force Text
logMessage = IO (Maybe Ref) -> m (Maybe Ref)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Ref) -> m (Maybe Ref))
-> IO (Maybe Ref) -> m (Maybe Ref)
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CString
newName' <- Text -> IO CString
textToCString Text
newName
let force' :: CInt
force' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
force
CString
logMessage' <- Text -> IO CString
textToCString Text
logMessage
IO (Maybe Ref) -> IO () -> IO (Maybe Ref)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Ref
result <- (Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref))
-> (Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref)
forall a b. (a -> b) -> a -> b
$ Ptr Ref
-> CString -> CInt -> CString -> Ptr (Ptr GError) -> IO (Ptr Ref)
ggit_ref_rename Ptr Ref
ref' CString
newName' CInt
force' CString
logMessage'
Maybe Ref
maybeResult <- Ptr Ref -> (Ptr Ref -> IO Ref) -> IO (Maybe Ref)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Ref
result ((Ptr Ref -> IO Ref) -> IO (Maybe Ref))
-> (Ptr Ref -> IO Ref) -> IO (Maybe Ref)
forall a b. (a -> b) -> a -> b
$ \Ptr Ref
result' -> do
Ref
result'' <- ((ManagedPtr Ref -> Ref) -> Ptr Ref -> IO Ref
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Ref -> Ref
Ref) Ptr Ref
result'
Ref -> IO Ref
forall (m :: * -> *) a. Monad m => a -> m a
return Ref
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
newName'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
logMessage'
Maybe Ref -> IO (Maybe Ref)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Ref
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
newName'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
logMessage'
)
#if defined(ENABLE_OVERLOADING)
data RefRenameMethodInfo
instance (signature ~ (T.Text -> Bool -> T.Text -> m (Maybe Ref)), MonadIO m, IsRef a) => O.OverloadedMethod RefRenameMethodInfo a signature where
overloadedMethod = refRename
instance O.OverloadedMethodInfo RefRenameMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refRename",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refRename"
}
#endif
foreign import ccall "ggit_ref_resolve" ggit_ref_resolve ::
Ptr Ref ->
Ptr (Ptr GError) ->
IO (Ptr Ref)
refResolve ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe Ref)
refResolve :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe Ref)
refResolve a
ref = IO (Maybe Ref) -> m (Maybe Ref)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Ref) -> m (Maybe Ref))
-> IO (Maybe Ref) -> m (Maybe Ref)
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
IO (Maybe Ref) -> IO () -> IO (Maybe Ref)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Ref
result <- (Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref))
-> (Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref)
forall a b. (a -> b) -> a -> b
$ Ptr Ref -> Ptr (Ptr GError) -> IO (Ptr Ref)
ggit_ref_resolve Ptr Ref
ref'
Maybe Ref
maybeResult <- Ptr Ref -> (Ptr Ref -> IO Ref) -> IO (Maybe Ref)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Ref
result ((Ptr Ref -> IO Ref) -> IO (Maybe Ref))
-> (Ptr Ref -> IO Ref) -> IO (Maybe Ref)
forall a b. (a -> b) -> a -> b
$ \Ptr Ref
result' -> do
Ref
result'' <- ((ManagedPtr Ref -> Ref) -> Ptr Ref -> IO Ref
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Ref -> Ref
Ref) Ptr Ref
result'
Ref -> IO Ref
forall (m :: * -> *) a. Monad m => a -> m a
return Ref
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
Maybe Ref -> IO (Maybe Ref)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Ref
maybeResult
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data RefResolveMethodInfo
instance (signature ~ (m (Maybe Ref)), MonadIO m, IsRef a) => O.OverloadedMethod RefResolveMethodInfo a signature where
overloadedMethod = refResolve
instance O.OverloadedMethodInfo RefResolveMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refResolve",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refResolve"
}
#endif
foreign import ccall "ggit_ref_set_symbolic_target" ggit_ref_set_symbolic_target ::
Ptr Ref ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr Ref)
refSetSymbolicTarget ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> T.Text
-> T.Text
-> m (Maybe Ref)
refSetSymbolicTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> Text -> Text -> m (Maybe Ref)
refSetSymbolicTarget a
ref Text
target Text
logMessage = IO (Maybe Ref) -> m (Maybe Ref)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Ref) -> m (Maybe Ref))
-> IO (Maybe Ref) -> m (Maybe Ref)
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CString
target' <- Text -> IO CString
textToCString Text
target
CString
logMessage' <- Text -> IO CString
textToCString Text
logMessage
IO (Maybe Ref) -> IO () -> IO (Maybe Ref)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Ref
result <- (Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref))
-> (Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref)
forall a b. (a -> b) -> a -> b
$ Ptr Ref -> CString -> CString -> Ptr (Ptr GError) -> IO (Ptr Ref)
ggit_ref_set_symbolic_target Ptr Ref
ref' CString
target' CString
logMessage'
Maybe Ref
maybeResult <- Ptr Ref -> (Ptr Ref -> IO Ref) -> IO (Maybe Ref)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Ref
result ((Ptr Ref -> IO Ref) -> IO (Maybe Ref))
-> (Ptr Ref -> IO Ref) -> IO (Maybe Ref)
forall a b. (a -> b) -> a -> b
$ \Ptr Ref
result' -> do
Ref
result'' <- ((ManagedPtr Ref -> Ref) -> Ptr Ref -> IO Ref
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Ref -> Ref
Ref) Ptr Ref
result'
Ref -> IO Ref
forall (m :: * -> *) a. Monad m => a -> m a
return Ref
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
target'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
logMessage'
Maybe Ref -> IO (Maybe Ref)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Ref
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
target'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
logMessage'
)
#if defined(ENABLE_OVERLOADING)
data RefSetSymbolicTargetMethodInfo
instance (signature ~ (T.Text -> T.Text -> m (Maybe Ref)), MonadIO m, IsRef a) => O.OverloadedMethod RefSetSymbolicTargetMethodInfo a signature where
overloadedMethod = refSetSymbolicTarget
instance O.OverloadedMethodInfo RefSetSymbolicTargetMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refSetSymbolicTarget",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refSetSymbolicTarget"
}
#endif
foreign import ccall "ggit_ref_set_target" ggit_ref_set_target ::
Ptr Ref ->
Ptr Ggit.OId.OId ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr Ref)
refSetTarget ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> Ggit.OId.OId
-> T.Text
-> m (Maybe Ref)
refSetTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> OId -> Text -> m (Maybe Ref)
refSetTarget a
ref OId
oid Text
logMessage = IO (Maybe Ref) -> m (Maybe Ref)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Ref) -> m (Maybe Ref))
-> IO (Maybe Ref) -> m (Maybe Ref)
forall a b. (a -> b) -> a -> b
$ do
Ptr Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
Ptr OId
oid' <- OId -> IO (Ptr OId)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr OId
oid
CString
logMessage' <- Text -> IO CString
textToCString Text
logMessage
IO (Maybe Ref) -> IO () -> IO (Maybe Ref)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Ref
result <- (Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref))
-> (Ptr (Ptr GError) -> IO (Ptr Ref)) -> IO (Ptr Ref)
forall a b. (a -> b) -> a -> b
$ Ptr Ref -> Ptr OId -> CString -> Ptr (Ptr GError) -> IO (Ptr Ref)
ggit_ref_set_target Ptr Ref
ref' Ptr OId
oid' CString
logMessage'
Maybe Ref
maybeResult <- Ptr Ref -> (Ptr Ref -> IO Ref) -> IO (Maybe Ref)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Ref
result ((Ptr Ref -> IO Ref) -> IO (Maybe Ref))
-> (Ptr Ref -> IO Ref) -> IO (Maybe Ref)
forall a b. (a -> b) -> a -> b
$ \Ptr Ref
result' -> do
Ref
result'' <- ((ManagedPtr Ref -> Ref) -> Ptr Ref -> IO Ref
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Ref -> Ref
Ref) Ptr Ref
result'
Ref -> IO Ref
forall (m :: * -> *) a. Monad m => a -> m a
return Ref
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
ref
OId -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr OId
oid
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
logMessage'
Maybe Ref -> IO (Maybe Ref)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Ref
maybeResult
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
logMessage'
)
#if defined(ENABLE_OVERLOADING)
data RefSetTargetMethodInfo
instance (signature ~ (Ggit.OId.OId -> T.Text -> m (Maybe Ref)), MonadIO m, IsRef a) => O.OverloadedMethod RefSetTargetMethodInfo a signature where
overloadedMethod = refSetTarget
instance O.OverloadedMethodInfo RefSetTargetMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refSetTarget",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refSetTarget"
}
#endif
foreign import ccall "ggit_ref_to_string" ggit_ref_to_string ::
Ptr Ref ->
IO CString
refToString ::
(B.CallStack.HasCallStack, MonadIO m, IsRef a) =>
a
-> m (Maybe T.Text)
refToString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRef a) =>
a -> m (Maybe Text)
refToString a
ref = 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 Ref
ref' <- a -> IO (Ptr Ref)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
ref
CString
result <- Ptr Ref -> IO CString
ggit_ref_to_string Ptr Ref
ref'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
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
ref
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data RefToStringMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRef a) => O.OverloadedMethod RefToStringMethodInfo a signature where
overloadedMethod = refToString
instance O.OverloadedMethodInfo RefToStringMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Ggit.Objects.Ref.refToString",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ggit-1.0.10/docs/GI-Ggit-Objects-Ref.html#v:refToString"
}
#endif
foreign import ccall "ggit_ref_is_valid_name" ggit_ref_is_valid_name ::
CString ->
IO CInt
refIsValidName ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
refIsValidName :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bool
refIsValidName Text
name = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
CInt
result <- CString -> IO CInt
ggit_ref_is_valid_name CString
name'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif