{-# 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 ,
noPushOptions ,
#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.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 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 (ManagedPtr PushOptions)
deriving (Eq)
foreign import ccall "ggit_push_options_get_type"
c_ggit_push_options_get_type :: IO GType
instance GObject PushOptions where
gobjectType = c_ggit_push_options_get_type
instance B.GValue.IsGValue PushOptions where
toGValue o = do
gtype <- c_ggit_push_options_get_type
B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)
fromGValue gv = do
ptr <- B.GValue.get_object gv :: IO (Ptr PushOptions)
B.ManagedPtr.newObject PushOptions ptr
class (GObject o, O.IsDescendantOf PushOptions o) => IsPushOptions o
instance (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 = liftIO . unsafeCastTo PushOptions
noPushOptions :: Maybe PushOptions
noPushOptions = 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.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 obj = liftIO $ B.Properties.getObjectPropertyObject obj "callbacks" Ggit.RemoteCallbacks.RemoteCallbacks
setPushOptionsCallbacks :: (MonadIO m, IsPushOptions o, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => o -> a -> m ()
setPushOptionsCallbacks obj val = liftIO $ B.Properties.setObjectPropertyObject obj "callbacks" (Just val)
constructPushOptionsCallbacks :: (IsPushOptions o, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => a -> IO (GValueConstruct o)
constructPushOptionsCallbacks val = B.Properties.constructObjectPropertyObject "callbacks" (Just val)
clearPushOptionsCallbacks :: (MonadIO m, IsPushOptions o) => o -> m ()
clearPushOptionsCallbacks obj = liftIO $ B.Properties.setObjectPropertyObject obj "callbacks" (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 obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "parallelism"
setPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> Int32 -> m ()
setPushOptionsParallelism obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "parallelism" val
constructPushOptionsParallelism :: (IsPushOptions o) => Int32 -> IO (GValueConstruct o)
constructPushOptionsParallelism val = B.Properties.constructObjectPropertyInt32 "parallelism" 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 = liftIO $ do
result <- ggit_push_options_new
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject PushOptions) result'
return result''
return 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 options = liftIO $ do
options' <- unsafeManagedPtrCastPtr options
result <- ggit_push_options_get_parallelism options'
touchManagedPtr options
return 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 options = liftIO $ do
options' <- unsafeManagedPtrCastPtr options
result <- ggit_push_options_get_remote_callbacks options'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newObject Ggit.RemoteCallbacks.RemoteCallbacks) result'
return result''
touchManagedPtr options
return 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 options parallelism = liftIO $ do
options' <- unsafeManagedPtrCastPtr options
ggit_push_options_set_parallelism options' parallelism
touchManagedPtr options
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 options callbacks = liftIO $ do
options' <- unsafeManagedPtrCastPtr options
callbacks' <- unsafeManagedPtrCastPtr callbacks
ggit_push_options_set_remote_callbacks options' callbacks'
touchManagedPtr options
touchManagedPtr callbacks
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