{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents a git push options.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Ggit.Objects.PushOptions
    ( 

-- * Exported types
    PushOptions(..)                         ,
    IsPushOptions                           ,
    toPushOptions                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getParallelism]("GI.Ggit.Objects.PushOptions#g:method:getParallelism"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRemoteCallbacks]("GI.Ggit.Objects.PushOptions#g:method:getRemoteCallbacks").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParallelism]("GI.Ggit.Objects.PushOptions#g:method:setParallelism"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRemoteCallbacks]("GI.Ggit.Objects.PushOptions#g:method:setRemoteCallbacks").

#if defined(ENABLE_OVERLOADING)
    ResolvePushOptionsMethod                ,
#endif

-- ** getParallelism #method:getParallelism#

#if defined(ENABLE_OVERLOADING)
    PushOptionsGetParallelismMethodInfo     ,
#endif
    pushOptionsGetParallelism               ,


-- ** getRemoteCallbacks #method:getRemoteCallbacks#

#if defined(ENABLE_OVERLOADING)
    PushOptionsGetRemoteCallbacksMethodInfo ,
#endif
    pushOptionsGetRemoteCallbacks           ,


-- ** new #method:new#

    pushOptionsNew                          ,


-- ** setParallelism #method:setParallelism#

#if defined(ENABLE_OVERLOADING)
    PushOptionsSetParallelismMethodInfo     ,
#endif
    pushOptionsSetParallelism               ,


-- ** setRemoteCallbacks #method:setRemoteCallbacks#

#if defined(ENABLE_OVERLOADING)
    PushOptionsSetRemoteCallbacksMethodInfo ,
#endif
    pushOptionsSetRemoteCallbacks           ,




 -- * Properties


-- ** callbacks #attr:callbacks#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    PushOptionsCallbacksPropertyInfo        ,
#endif
    clearPushOptionsCallbacks               ,
    constructPushOptionsCallbacks           ,
    getPushOptionsCallbacks                 ,
#if defined(ENABLE_OVERLOADING)
    pushOptionsCallbacks                    ,
#endif
    setPushOptionsCallbacks                 ,


-- ** parallelism #attr:parallelism#
-- | /No description available in the introspection data./

#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

-- | Memory-managed wrapper type.
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

-- | Type class for types which can be safely cast to `PushOptions`, for instance with `toPushOptions`.
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]

-- | Cast to `PushOptions`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- | Convert 'PushOptions' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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

-- VVV Prop "callbacks"
   -- Type: TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@callbacks@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pushOptions #callbacks
-- @
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

-- | Set the value of the “@callbacks@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pushOptions [ #callbacks 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Construct a `GValueConstruct` with valid value for the “@callbacks@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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)

-- | Set the value of the “@callbacks@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #callbacks
-- @
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

-- VVV Prop "parallelism"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@parallelism@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pushOptions #parallelism
-- @
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"

-- | Set the value of the “@parallelism@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pushOptions [ #parallelism 'Data.GI.Base.Attributes.:=' value ]
-- @
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

-- | Construct a `GValueConstruct` with valid value for the “@parallelism@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
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

-- method PushOptions::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "PushOptions" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_push_options_new" ggit_push_options_new :: 
    IO (Ptr PushOptions)

-- | Create a new push options object.
pushOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe PushOptions)
    -- ^ __Returns:__ a t'GI.Ggit.Objects.PushOptions.PushOptions' or 'P.Nothing'.
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

-- method PushOptions::get_parallelism
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "PushOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitPushOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "ggit_push_options_get_parallelism" ggit_push_options_get_parallelism :: 
    Ptr PushOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"})
    IO Int32

-- | Get the number of parallel threads to use when creating the pack file
-- to push. The special value 0 indicates that the number of threads will
-- be automatically detected.
pushOptionsGetParallelism ::
    (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.PushOptions.PushOptions'.
    -> m Int32
    -- ^ __Returns:__ the number of parallel threads, or 0 for auto-detect.
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

-- method PushOptions::get_remote_callbacks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "PushOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitPushOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Ggit" , name = "RemoteCallbacks" })
-- throws : False
-- Skip return : False

foreign import ccall "ggit_push_options_get_remote_callbacks" ggit_push_options_get_remote_callbacks :: 
    Ptr PushOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"})
    IO (Ptr Ggit.RemoteCallbacks.RemoteCallbacks)

-- | gets the remote callbacks object
pushOptionsGetRemoteCallbacks ::
    (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.PushOptions.PushOptions'.
    -> m (Maybe Ggit.RemoteCallbacks.RemoteCallbacks)
    -- ^ __Returns:__ the object\'s id or 'P.Nothing'.
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

-- method PushOptions::set_parallelism
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "PushOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitPushOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parallelism"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of threads, or 0 for auto-detect."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_push_options_set_parallelism" ggit_push_options_set_parallelism :: 
    Ptr PushOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"})
    Int32 ->                                -- parallelism : TBasicType TInt
    IO ()

-- | Set the number of parallel threads to use when creating the pack file
-- to push. The special value 0 can be specified for /@parallelism@/ indicating that
-- the number of threads will be automatically detected.
pushOptionsSetParallelism ::
    (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.PushOptions.PushOptions'.
    -> Int32
    -- ^ /@parallelism@/: the number of threads, or 0 for auto-detect.
    -> 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

-- method PushOptions::set_remote_callbacks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "options"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "PushOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GgitPushOptions."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callbacks"
--           , argType =
--               TInterface Name { namespace = "Ggit" , name = "RemoteCallbacks" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GgitRemoteCallbacks"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ggit_push_options_set_remote_callbacks" ggit_push_options_set_remote_callbacks :: 
    Ptr PushOptions ->                      -- options : TInterface (Name {namespace = "Ggit", name = "PushOptions"})
    Ptr Ggit.RemoteCallbacks.RemoteCallbacks -> -- callbacks : TInterface (Name {namespace = "Ggit", name = "RemoteCallbacks"})
    IO ()

-- | Set the remote callbacks for the push options
pushOptionsSetRemoteCallbacks ::
    (B.CallStack.HasCallStack, MonadIO m, IsPushOptions a, Ggit.RemoteCallbacks.IsRemoteCallbacks b) =>
    a
    -- ^ /@options@/: a t'GI.Ggit.Objects.PushOptions.PushOptions'.
    -> b
    -- ^ /@callbacks@/: the t'GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks'
    -> 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