{-# 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.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 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
instance B.GValue.IsGValue PushOptions where
toGValue :: PushOptions -> IO GValue
toGValue PushOptions
o = do
GType
gtype <- IO GType
c_ggit_push_options_get_type
PushOptions -> (Ptr PushOptions -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PushOptions
o (GType
-> (GValue -> Ptr PushOptions -> IO ())
-> Ptr PushOptions
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr PushOptions -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO PushOptions
fromGValue GValue
gv = do
Ptr PushOptions
ptr <- GValue -> IO (Ptr PushOptions)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr PushOptions)
(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
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 :: (MonadIO m, IsPushOptions o) => o -> m PushOptions
toPushOptions :: o -> m PushOptions
toPushOptions = IO PushOptions -> m PushOptions
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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'
unsafeCastTo ManagedPtr PushOptions -> PushOptions
PushOptions
#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.MethodInfo 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
#endif
getPushOptionsCallbacks :: (MonadIO m, IsPushOptions o) => o -> m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
getPushOptionsCallbacks :: o -> m (Maybe RemoteCallbacks)
getPushOptionsCallbacks o
obj = 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
$ 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 :: o -> a -> m ()
setPushOptionsCallbacks o
obj a
val = 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 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 :: 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
$ 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 :: 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
#endif
getPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> m Int32
getPushOptionsParallelism :: o -> m Int32
getPushOptionsParallelism o
obj = 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
$ 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 :: o -> Int32 -> m ()
setPushOptionsParallelism o
obj Int32
val = 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 -> 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 :: 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
$ 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
#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 :: 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 :: 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.MethodInfo PushOptionsGetParallelismMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo PushOptionsGetRemoteCallbacksMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo PushOptionsSetParallelismMethodInfo a signature where
overloadedMethod = 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 :: 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.MethodInfo PushOptionsSetRemoteCallbacksMethodInfo a signature where
overloadedMethod = pushOptionsSetRemoteCallbacks
#endif