{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Ggit.Objects.PushOptions
(
PushOptions(..) ,
IsPushOptions ,
toPushOptions ,
#if defined(ENABLE_OVERLOADING)
ResolvePushOptionsMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
PushOptionsGetParallelismMethodInfo ,
#endif
pushOptionsGetParallelism ,
#if defined(ENABLE_OVERLOADING)
PushOptionsGetRemoteCallbacksMethodInfo ,
#endif
pushOptionsGetRemoteCallbacks ,
pushOptionsNew ,
#if defined(ENABLE_OVERLOADING)
PushOptionsSetParallelismMethodInfo ,
#endif
pushOptionsSetParallelism ,
#if defined(ENABLE_OVERLOADING)
PushOptionsSetRemoteCallbacksMethodInfo ,
#endif
pushOptionsSetRemoteCallbacks ,
#if defined(ENABLE_OVERLOADING)
PushOptionsCallbacksPropertyInfo ,
#endif
clearPushOptionsCallbacks ,
constructPushOptionsCallbacks ,
getPushOptionsCallbacks ,
#if defined(ENABLE_OVERLOADING)
pushOptionsCallbacks ,
#endif
setPushOptionsCallbacks ,
#if defined(ENABLE_OVERLOADING)
PushOptionsParallelismPropertyInfo ,
#endif
constructPushOptionsParallelism ,
getPushOptionsParallelism ,
#if defined(ENABLE_OVERLOADING)
pushOptionsParallelism ,
#endif
setPushOptionsParallelism ,
) 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.RemoteCallbacks as Ggit.RemoteCallbacks
newtype PushOptions = PushOptions (SP.ManagedPtr PushOptions)
deriving (PushOptions -> PushOptions -> Bool
(PushOptions -> PushOptions -> Bool)
-> (PushOptions -> PushOptions -> Bool) -> Eq PushOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PushOptions -> PushOptions -> Bool
$c/= :: PushOptions -> PushOptions -> Bool
== :: PushOptions -> PushOptions -> Bool
$c== :: PushOptions -> PushOptions -> Bool
Eq)
instance SP.ManagedPtrNewtype PushOptions where
toManagedPtr :: PushOptions -> ManagedPtr PushOptions
toManagedPtr (PushOptions ManagedPtr PushOptions
p) = ManagedPtr PushOptions
p
foreign import ccall "ggit_push_options_get_type"
c_ggit_push_options_get_type :: IO B.Types.GType
instance B.Types.TypedObject PushOptions where
glibType :: IO GType
glibType = IO GType
c_ggit_push_options_get_type
instance B.Types.GObject PushOptions
class (SP.GObject o, O.IsDescendantOf PushOptions o) => IsPushOptions o
instance (SP.GObject o, O.IsDescendantOf PushOptions o) => IsPushOptions o
instance O.HasParentTypes PushOptions
type instance O.ParentTypes PushOptions = '[GObject.Object.Object]
toPushOptions :: (MIO.MonadIO m, IsPushOptions o) => o -> m PushOptions
toPushOptions :: forall (m :: * -> *) o.
(MonadIO m, IsPushOptions o) =>
o -> m PushOptions
toPushOptions = IO PushOptions -> m PushOptions
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO PushOptions -> m PushOptions)
-> (o -> IO PushOptions) -> o -> m PushOptions
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr PushOptions -> PushOptions) -> o -> IO PushOptions
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr PushOptions -> PushOptions
PushOptions
instance B.GValue.IsGValue (Maybe PushOptions) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ggit_push_options_get_type
gvalueSet_ :: Ptr GValue -> Maybe PushOptions -> IO ()
gvalueSet_ Ptr GValue
gv Maybe PushOptions
P.Nothing = Ptr GValue -> Ptr PushOptions -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr PushOptions
forall a. Ptr a
FP.nullPtr :: FP.Ptr PushOptions)
gvalueSet_ Ptr GValue
gv (P.Just PushOptions
obj) = PushOptions -> (Ptr PushOptions -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PushOptions
obj (Ptr GValue -> Ptr PushOptions -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe PushOptions)
gvalueGet_ Ptr GValue
gv = do
Ptr PushOptions
ptr <- Ptr GValue -> IO (Ptr PushOptions)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr PushOptions)
if Ptr PushOptions
ptr Ptr PushOptions -> Ptr PushOptions -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr PushOptions
forall a. Ptr a
FP.nullPtr
then PushOptions -> Maybe PushOptions
forall a. a -> Maybe a
P.Just (PushOptions -> Maybe PushOptions)
-> IO PushOptions -> IO (Maybe PushOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr PushOptions -> PushOptions)
-> Ptr PushOptions -> IO PushOptions
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr PushOptions -> PushOptions
PushOptions Ptr PushOptions
ptr
else Maybe PushOptions -> IO (Maybe PushOptions)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PushOptions
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolvePushOptionsMethod (t :: Symbol) (o :: *) :: * where
ResolvePushOptionsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolvePushOptionsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolvePushOptionsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolvePushOptionsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolvePushOptionsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolvePushOptionsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolvePushOptionsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolvePushOptionsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolvePushOptionsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolvePushOptionsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolvePushOptionsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolvePushOptionsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolvePushOptionsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolvePushOptionsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolvePushOptionsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolvePushOptionsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolvePushOptionsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolvePushOptionsMethod "getParallelism" o = PushOptionsGetParallelismMethodInfo
ResolvePushOptionsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolvePushOptionsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolvePushOptionsMethod "getRemoteCallbacks" o = PushOptionsGetRemoteCallbacksMethodInfo
ResolvePushOptionsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolvePushOptionsMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolvePushOptionsMethod "setParallelism" o = PushOptionsSetParallelismMethodInfo
ResolvePushOptionsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolvePushOptionsMethod "setRemoteCallbacks" o = PushOptionsSetRemoteCallbacksMethodInfo
ResolvePushOptionsMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolvePushOptionsMethod t PushOptions, O.OverloadedMethod info PushOptions p) => OL.IsLabel t (PushOptions -> 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 ~ ResolvePushOptionsMethod t PushOptions, O.OverloadedMethod info PushOptions p, R.HasField t PushOptions p) => R.HasField t PushOptions p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolvePushOptionsMethod t PushOptions, O.OverloadedMethodInfo info PushOptions) => OL.IsLabel t (O.MethodProxy info PushOptions) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getPushOptionsCallbacks :: (MonadIO m, IsPushOptions o) => o -> m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
getPushOptionsCallbacks :: forall (m :: * -> *) o.
(MonadIO m, IsPushOptions o) =>
o -> m (Maybe RemoteCallbacks)
getPushOptionsCallbacks o
obj = IO (Maybe RemoteCallbacks) -> m (Maybe RemoteCallbacks)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe RemoteCallbacks) -> m (Maybe RemoteCallbacks))
-> IO (Maybe RemoteCallbacks) -> m (Maybe RemoteCallbacks)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr RemoteCallbacks -> RemoteCallbacks)
-> IO (Maybe RemoteCallbacks)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"callbacks" ManagedPtr RemoteCallbacks -> RemoteCallbacks
Ggit.RemoteCallbacks.RemoteCallbacks
setPushOptionsCallbacks :: (MonadIO m, IsPushOptions o, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => o -> a -> m ()
setPushOptionsCallbacks :: forall (m :: * -> *) o a.
(MonadIO m, IsPushOptions o, IsRemoteCallbacks a) =>
o -> a -> m ()
setPushOptionsCallbacks o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"callbacks" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)
constructPushOptionsCallbacks :: (IsPushOptions o, MIO.MonadIO m, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => a -> m (GValueConstruct o)
constructPushOptionsCallbacks :: forall o (m :: * -> *) a.
(IsPushOptions o, MonadIO m, IsRemoteCallbacks a) =>
a -> m (GValueConstruct o)
constructPushOptionsCallbacks 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
"callbacks" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
clearPushOptionsCallbacks :: (MonadIO m, IsPushOptions o) => o -> m ()
clearPushOptionsCallbacks :: forall (m :: * -> *) o. (MonadIO m, IsPushOptions o) => o -> m ()
clearPushOptionsCallbacks o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe RemoteCallbacks -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"callbacks" (Maybe RemoteCallbacks
forall a. Maybe a
Nothing :: Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
#if defined(ENABLE_OVERLOADING)
data PushOptionsCallbacksPropertyInfo
instance AttrInfo PushOptionsCallbacksPropertyInfo where
type AttrAllowedOps PushOptionsCallbacksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint PushOptionsCallbacksPropertyInfo = IsPushOptions
type AttrSetTypeConstraint PushOptionsCallbacksPropertyInfo = Ggit.RemoteCallbacks.IsRemoteCallbacks
type AttrTransferTypeConstraint PushOptionsCallbacksPropertyInfo = Ggit.RemoteCallbacks.IsRemoteCallbacks
type AttrTransferType PushOptionsCallbacksPropertyInfo = Ggit.RemoteCallbacks.RemoteCallbacks
type AttrGetType PushOptionsCallbacksPropertyInfo = (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
type AttrLabel PushOptionsCallbacksPropertyInfo = "callbacks"
type AttrOrigin PushOptionsCallbacksPropertyInfo = PushOptions
attrGet = getPushOptionsCallbacks
attrSet = setPushOptionsCallbacks
attrTransfer _ v = do
unsafeCastTo Ggit.RemoteCallbacks.RemoteCallbacks v
attrConstruct = constructPushOptionsCallbacks
attrClear = clearPushOptionsCallbacks
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.PushOptions.callbacks"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-PushOptions.html#g:attr:callbacks"
})
#endif
getPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> m Int32
getPushOptionsParallelism :: forall (m :: * -> *) o.
(MonadIO m, IsPushOptions o) =>
o -> m Int32
getPushOptionsParallelism o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"parallelism"
setPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> Int32 -> m ()
setPushOptionsParallelism :: forall (m :: * -> *) o.
(MonadIO m, IsPushOptions o) =>
o -> Int32 -> m ()
setPushOptionsParallelism o
obj Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"parallelism" Int32
val
constructPushOptionsParallelism :: (IsPushOptions o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructPushOptionsParallelism :: forall o (m :: * -> *).
(IsPushOptions o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructPushOptionsParallelism Int32
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 -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"parallelism" Int32
val
#if defined(ENABLE_OVERLOADING)
data PushOptionsParallelismPropertyInfo
instance AttrInfo PushOptionsParallelismPropertyInfo where
type AttrAllowedOps PushOptionsParallelismPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint PushOptionsParallelismPropertyInfo = IsPushOptions
type AttrSetTypeConstraint PushOptionsParallelismPropertyInfo = (~) Int32
type AttrTransferTypeConstraint PushOptionsParallelismPropertyInfo = (~) Int32
type AttrTransferType PushOptionsParallelismPropertyInfo = Int32
type AttrGetType PushOptionsParallelismPropertyInfo = Int32
type AttrLabel PushOptionsParallelismPropertyInfo = "parallelism"
type AttrOrigin PushOptionsParallelismPropertyInfo = PushOptions
attrGet = getPushOptionsParallelism
attrSet = setPushOptionsParallelism
attrTransfer _ v = do
return v
attrConstruct = constructPushOptionsParallelism
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.PushOptions.parallelism"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-PushOptions.html#g:attr:parallelism"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PushOptions
type instance O.AttributeList PushOptions = PushOptionsAttributeList
type PushOptionsAttributeList = ('[ '("callbacks", PushOptionsCallbacksPropertyInfo), '("parallelism", PushOptionsParallelismPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
pushOptionsCallbacks :: AttrLabelProxy "callbacks"
pushOptionsCallbacks = AttrLabelProxy
pushOptionsParallelism :: AttrLabelProxy "parallelism"
pushOptionsParallelism = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList PushOptions = PushOptionsSignalList
type PushOptionsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ggit_push_options_new" ggit_push_options_new ::
IO (Ptr PushOptions)
pushOptionsNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m (Maybe PushOptions)
pushOptionsNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m (Maybe PushOptions)
pushOptionsNew = IO (Maybe PushOptions) -> m (Maybe PushOptions)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PushOptions) -> m (Maybe PushOptions))
-> IO (Maybe PushOptions) -> m (Maybe PushOptions)
forall a b. (a -> b) -> a -> b
$ do
Ptr PushOptions
result <- IO (Ptr PushOptions)
ggit_push_options_new
Maybe PushOptions
maybeResult <- Ptr PushOptions
-> (Ptr PushOptions -> IO PushOptions) -> IO (Maybe PushOptions)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PushOptions
result ((Ptr PushOptions -> IO PushOptions) -> IO (Maybe PushOptions))
-> (Ptr PushOptions -> IO PushOptions) -> IO (Maybe PushOptions)
forall a b. (a -> b) -> a -> b
$ \Ptr PushOptions
result' -> do
PushOptions
result'' <- ((ManagedPtr PushOptions -> PushOptions)
-> Ptr PushOptions -> IO PushOptions
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PushOptions -> PushOptions
PushOptions) Ptr PushOptions
result'
PushOptions -> IO PushOptions
forall (m :: * -> *) a. Monad m => a -> m a
return PushOptions
result''
Maybe PushOptions -> IO (Maybe PushOptions)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PushOptions
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ggit_push_options_get_parallelism" ggit_push_options_get_parallelism ::
Ptr PushOptions ->
IO Int32
pushOptionsGetParallelism ::
(B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
a
-> m Int32
pushOptionsGetParallelism :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPushOptions a) =>
a -> m Int32
pushOptionsGetParallelism a
options = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr PushOptions
options' <- a -> IO (Ptr PushOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Int32
result <- Ptr PushOptions -> IO Int32
ggit_push_options_get_parallelism Ptr PushOptions
options'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data PushOptionsGetParallelismMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsPushOptions a) => O.OverloadedMethod PushOptionsGetParallelismMethodInfo a signature where
overloadedMethod = pushOptionsGetParallelism
instance O.OverloadedMethodInfo PushOptionsGetParallelismMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.PushOptions.pushOptionsGetParallelism",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-PushOptions.html#v:pushOptionsGetParallelism"
})
#endif
foreign import ccall "ggit_push_options_get_remote_callbacks" ggit_push_options_get_remote_callbacks ::
Ptr PushOptions ->
IO (Ptr Ggit.RemoteCallbacks.RemoteCallbacks)
pushOptionsGetRemoteCallbacks ::
(B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
a
-> m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
pushOptionsGetRemoteCallbacks :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPushOptions a) =>
a -> m (Maybe RemoteCallbacks)
pushOptionsGetRemoteCallbacks a
options = IO (Maybe RemoteCallbacks) -> m (Maybe RemoteCallbacks)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe RemoteCallbacks) -> m (Maybe RemoteCallbacks))
-> IO (Maybe RemoteCallbacks) -> m (Maybe RemoteCallbacks)
forall a b. (a -> b) -> a -> b
$ do
Ptr PushOptions
options' <- a -> IO (Ptr PushOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr RemoteCallbacks
result <- Ptr PushOptions -> IO (Ptr RemoteCallbacks)
ggit_push_options_get_remote_callbacks Ptr PushOptions
options'
Maybe RemoteCallbacks
maybeResult <- Ptr RemoteCallbacks
-> (Ptr RemoteCallbacks -> IO RemoteCallbacks)
-> IO (Maybe RemoteCallbacks)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr RemoteCallbacks
result ((Ptr RemoteCallbacks -> IO RemoteCallbacks)
-> IO (Maybe RemoteCallbacks))
-> (Ptr RemoteCallbacks -> IO RemoteCallbacks)
-> IO (Maybe RemoteCallbacks)
forall a b. (a -> b) -> a -> b
$ \Ptr RemoteCallbacks
result' -> do
RemoteCallbacks
result'' <- ((ManagedPtr RemoteCallbacks -> RemoteCallbacks)
-> Ptr RemoteCallbacks -> IO RemoteCallbacks
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr RemoteCallbacks -> RemoteCallbacks
Ggit.RemoteCallbacks.RemoteCallbacks) Ptr RemoteCallbacks
result'
RemoteCallbacks -> IO RemoteCallbacks
forall (m :: * -> *) a. Monad m => a -> m a
return RemoteCallbacks
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
Maybe RemoteCallbacks -> IO (Maybe RemoteCallbacks)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe RemoteCallbacks
maybeResult
#if defined(ENABLE_OVERLOADING)
data PushOptionsGetRemoteCallbacksMethodInfo
instance (signature ~ (m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)), MonadIO m, IsPushOptions a) => O.OverloadedMethod PushOptionsGetRemoteCallbacksMethodInfo a signature where
overloadedMethod = pushOptionsGetRemoteCallbacks
instance O.OverloadedMethodInfo PushOptionsGetRemoteCallbacksMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.PushOptions.pushOptionsGetRemoteCallbacks",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-PushOptions.html#v:pushOptionsGetRemoteCallbacks"
})
#endif
foreign import ccall "ggit_push_options_set_parallelism" ggit_push_options_set_parallelism ::
Ptr PushOptions ->
Int32 ->
IO ()
pushOptionsSetParallelism ::
(B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
a
-> Int32
-> m ()
pushOptionsSetParallelism :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPushOptions a) =>
a -> Int32 -> m ()
pushOptionsSetParallelism a
options Int32
parallelism = 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 PushOptions
options' <- a -> IO (Ptr PushOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr PushOptions -> Int32 -> IO ()
ggit_push_options_set_parallelism Ptr PushOptions
options' Int32
parallelism
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PushOptionsSetParallelismMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsPushOptions a) => O.OverloadedMethod PushOptionsSetParallelismMethodInfo a signature where
overloadedMethod = pushOptionsSetParallelism
instance O.OverloadedMethodInfo PushOptionsSetParallelismMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.PushOptions.pushOptionsSetParallelism",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-PushOptions.html#v:pushOptionsSetParallelism"
})
#endif
foreign import ccall "ggit_push_options_set_remote_callbacks" ggit_push_options_set_remote_callbacks ::
Ptr PushOptions ->
Ptr Ggit.RemoteCallbacks.RemoteCallbacks ->
IO ()
pushOptionsSetRemoteCallbacks ::
(B.CallStack.HasCallStack, MonadIO m, IsPushOptions a, Ggit.RemoteCallbacks.IsRemoteCallbacks b) =>
a
-> b
-> m ()
pushOptionsSetRemoteCallbacks :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPushOptions a, IsRemoteCallbacks b) =>
a -> b -> m ()
pushOptionsSetRemoteCallbacks a
options b
callbacks = 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 PushOptions
options' <- a -> IO (Ptr PushOptions)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
options
Ptr RemoteCallbacks
callbacks' <- b -> IO (Ptr RemoteCallbacks)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
callbacks
Ptr PushOptions -> Ptr RemoteCallbacks -> IO ()
ggit_push_options_set_remote_callbacks Ptr PushOptions
options' Ptr RemoteCallbacks
callbacks'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
options
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
callbacks
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PushOptionsSetRemoteCallbacksMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsPushOptions a, Ggit.RemoteCallbacks.IsRemoteCallbacks b) => O.OverloadedMethod PushOptionsSetRemoteCallbacksMethodInfo a signature where
overloadedMethod = pushOptionsSetRemoteCallbacks
instance O.OverloadedMethodInfo PushOptionsSetRemoteCallbacksMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Ggit.Objects.PushOptions.pushOptionsSetRemoteCallbacks",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ggit-1.0.11/docs/GI-Ggit-Objects-PushOptions.html#v:pushOptionsSetRemoteCallbacks"
})
#endif