{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

Represents a git fetch options.
-}

module GI.Ggit.Structs.FetchOptions
    ( 

-- * Exported types
    FetchOptions(..)                        ,
    noFetchOptions                          ,


 -- * Methods
-- ** copy #method:copy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FetchOptionsCopyMethodInfo              ,
#endif
    fetchOptionsCopy                        ,


-- ** free #method:free#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FetchOptionsFreeMethodInfo              ,
#endif
    fetchOptionsFree                        ,


-- ** getDownloadTags #method:getDownloadTags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FetchOptionsGetDownloadTagsMethodInfo   ,
#endif
    fetchOptionsGetDownloadTags             ,


-- ** getRemoteCallbacks #method:getRemoteCallbacks#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FetchOptionsGetRemoteCallbacksMethodInfo,
#endif
    fetchOptionsGetRemoteCallbacks          ,


-- ** new #method:new#
    fetchOptionsNew                         ,


-- ** setDownloadTags #method:setDownloadTags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FetchOptionsSetDownloadTagsMethodInfo   ,
#endif
    fetchOptionsSetDownloadTags             ,


-- ** setRemoteCallbacks #method:setRemoteCallbacks#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FetchOptionsSetRemoteCallbacksMethodInfo,
#endif
    fetchOptionsSetRemoteCallbacks          ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 {-# SOURCE #-} qualified GI.Ggit.Enums as Ggit.Enums
import {-# SOURCE #-} qualified GI.Ggit.Objects.RemoteCallbacks as Ggit.RemoteCallbacks

newtype FetchOptions = FetchOptions (ManagedPtr FetchOptions)
foreign import ccall "ggit_fetch_options_get_type" c_ggit_fetch_options_get_type :: 
    IO GType

instance BoxedObject FetchOptions where
    boxedType _ = c_ggit_fetch_options_get_type

noFetchOptions :: Maybe FetchOptions
noFetchOptions = Nothing


#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList FetchOptions
type instance O.AttributeList FetchOptions = FetchOptionsAttributeList
type FetchOptionsAttributeList = ('[ ] :: [(Symbol, *)])
#endif

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

foreign import ccall "ggit_fetch_options_new" ggit_fetch_options_new :: 
    IO (Ptr FetchOptions)

{- |
Creates a new 'GI.Ggit.Structs.FetchOptions.FetchOptions'.
-}
fetchOptionsNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m FetchOptions
    {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -}
fetchOptionsNew  = liftIO $ do
    result <- ggit_fetch_options_new
    checkUnexpectedReturnNULL "fetchOptionsNew" result
    result' <- (wrapBoxed FetchOptions) result
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

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

foreign import ccall "ggit_fetch_options_copy" ggit_fetch_options_copy :: 
    Ptr FetchOptions ->                     -- fetch_options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"})
    IO (Ptr FetchOptions)

{- |
Copies /@fetchOptions@/ into a newly allocated 'GI.Ggit.Structs.FetchOptions.FetchOptions'.
-}
fetchOptionsCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FetchOptions
    {- ^ /@fetchOptions@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -}
    -> m FetchOptions
    {- ^ __Returns:__ a newly allocated 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -}
fetchOptionsCopy fetchOptions = liftIO $ do
    fetchOptions' <- unsafeManagedPtrGetPtr fetchOptions
    result <- ggit_fetch_options_copy fetchOptions'
    checkUnexpectedReturnNULL "fetchOptionsCopy" result
    result' <- (wrapBoxed FetchOptions) result
    touchManagedPtr fetchOptions
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FetchOptionsCopyMethodInfo
instance (signature ~ (m FetchOptions), MonadIO m) => O.MethodInfo FetchOptionsCopyMethodInfo FetchOptions signature where
    overloadedMethod _ = fetchOptionsCopy

#endif

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

foreign import ccall "ggit_fetch_options_free" ggit_fetch_options_free :: 
    Ptr FetchOptions ->                     -- fetch_options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"})
    IO ()

{- |
Frees /@fetchOptions@/.
-}
fetchOptionsFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FetchOptions
    {- ^ /@fetchOptions@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -}
    -> m ()
fetchOptionsFree fetchOptions = liftIO $ do
    fetchOptions' <- unsafeManagedPtrGetPtr fetchOptions
    ggit_fetch_options_free fetchOptions'
    touchManagedPtr fetchOptions
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FetchOptionsFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo FetchOptionsFreeMethodInfo FetchOptions signature where
    overloadedMethod _ = fetchOptionsFree

#endif

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

foreign import ccall "ggit_fetch_options_get_download_tags" ggit_fetch_options_get_download_tags :: 
    Ptr FetchOptions ->                     -- options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"})
    IO CUInt

{- |
Get how tags are being handled when fetching\/downloading.
-}
fetchOptionsGetDownloadTags ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FetchOptions
    {- ^ /@options@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -}
    -> m Ggit.Enums.RemoteDownloadTagsType
    {- ^ __Returns:__ a 'GI.Ggit.Enums.RemoteDownloadTagsType'. -}
fetchOptionsGetDownloadTags options = liftIO $ do
    options' <- unsafeManagedPtrGetPtr options
    result <- ggit_fetch_options_get_download_tags options'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FetchOptionsGetDownloadTagsMethodInfo
instance (signature ~ (m Ggit.Enums.RemoteDownloadTagsType), MonadIO m) => O.MethodInfo FetchOptionsGetDownloadTagsMethodInfo FetchOptions signature where
    overloadedMethod _ = fetchOptionsGetDownloadTags

#endif

-- method FetchOptions::get_remote_callbacks
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", 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_fetch_options_get_remote_callbacks" ggit_fetch_options_get_remote_callbacks :: 
    Ptr FetchOptions ->                     -- options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"})
    IO (Ptr Ggit.RemoteCallbacks.RemoteCallbacks)

{- |
Get the remote callbacks object or 'Nothing' if not set.
-}
fetchOptionsGetRemoteCallbacks ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FetchOptions
    {- ^ /@options@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -}
    -> m Ggit.RemoteCallbacks.RemoteCallbacks
    {- ^ __Returns:__ the remote callbacks or 'Nothing'. -}
fetchOptionsGetRemoteCallbacks options = liftIO $ do
    options' <- unsafeManagedPtrGetPtr options
    result <- ggit_fetch_options_get_remote_callbacks options'
    checkUnexpectedReturnNULL "fetchOptionsGetRemoteCallbacks" result
    result' <- (newObject Ggit.RemoteCallbacks.RemoteCallbacks) result
    touchManagedPtr options
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FetchOptionsGetRemoteCallbacksMethodInfo
instance (signature ~ (m Ggit.RemoteCallbacks.RemoteCallbacks), MonadIO m) => O.MethodInfo FetchOptionsGetRemoteCallbacksMethodInfo FetchOptions signature where
    overloadedMethod _ = fetchOptionsGetRemoteCallbacks

#endif

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

foreign import ccall "ggit_fetch_options_set_download_tags" ggit_fetch_options_set_download_tags :: 
    Ptr FetchOptions ->                     -- options : TInterface (Name {namespace = "Ggit", name = "FetchOptions"})
    CUInt ->                                -- download_tags : TInterface (Name {namespace = "Ggit", name = "RemoteDownloadTagsType"})
    IO ()

{- |
Set how tags are being handled when fetching\/downloading.
-}
fetchOptionsSetDownloadTags ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FetchOptions
    {- ^ /@options@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -}
    -> Ggit.Enums.RemoteDownloadTagsType
    {- ^ /@downloadTags@/: a 'GI.Ggit.Enums.RemoteDownloadTagsType'. -}
    -> m ()
fetchOptionsSetDownloadTags options downloadTags = liftIO $ do
    options' <- unsafeManagedPtrGetPtr options
    let downloadTags' = (fromIntegral . fromEnum) downloadTags
    ggit_fetch_options_set_download_tags options' downloadTags'
    touchManagedPtr options
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FetchOptionsSetDownloadTagsMethodInfo
instance (signature ~ (Ggit.Enums.RemoteDownloadTagsType -> m ()), MonadIO m) => O.MethodInfo FetchOptionsSetDownloadTagsMethodInfo FetchOptions signature where
    overloadedMethod _ = fetchOptionsSetDownloadTags

#endif

-- method FetchOptions::set_remote_callbacks
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "options", argType = TInterface (Name {namespace = "Ggit", name = "FetchOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GgitFetchOptions.", 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 = True, argDoc = Documentation {rawDocText = Just "a #GgitRemoteCallbacks or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

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

{- |
Set the fetch options object.
-}
fetchOptionsSetRemoteCallbacks ::
    (B.CallStack.HasCallStack, MonadIO m, Ggit.RemoteCallbacks.IsRemoteCallbacks a) =>
    FetchOptions
    {- ^ /@options@/: a 'GI.Ggit.Structs.FetchOptions.FetchOptions'. -}
    -> Maybe (a)
    {- ^ /@callbacks@/: a 'GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks' or 'Nothing'. -}
    -> m ()
fetchOptionsSetRemoteCallbacks options callbacks = liftIO $ do
    options' <- unsafeManagedPtrGetPtr options
    maybeCallbacks <- case callbacks of
        Nothing -> return nullPtr
        Just jCallbacks -> do
            jCallbacks' <- unsafeManagedPtrCastPtr jCallbacks
            return jCallbacks'
    ggit_fetch_options_set_remote_callbacks options' maybeCallbacks
    touchManagedPtr options
    whenJust callbacks touchManagedPtr
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FetchOptionsSetRemoteCallbacksMethodInfo
instance (signature ~ (Maybe (a) -> m ()), MonadIO m, Ggit.RemoteCallbacks.IsRemoteCallbacks a) => O.MethodInfo FetchOptionsSetRemoteCallbacksMethodInfo FetchOptions signature where
    overloadedMethod _ = fetchOptionsSetRemoteCallbacks

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveFetchOptionsMethod (t :: Symbol) (o :: *) :: * where
    ResolveFetchOptionsMethod "copy" o = FetchOptionsCopyMethodInfo
    ResolveFetchOptionsMethod "free" o = FetchOptionsFreeMethodInfo
    ResolveFetchOptionsMethod "getDownloadTags" o = FetchOptionsGetDownloadTagsMethodInfo
    ResolveFetchOptionsMethod "getRemoteCallbacks" o = FetchOptionsGetRemoteCallbacksMethodInfo
    ResolveFetchOptionsMethod "setDownloadTags" o = FetchOptionsSetDownloadTagsMethodInfo
    ResolveFetchOptionsMethod "setRemoteCallbacks" o = FetchOptionsSetRemoteCallbacksMethodInfo
    ResolveFetchOptionsMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFetchOptionsMethod t FetchOptions, O.MethodInfo info FetchOptions p) => O.IsLabelProxy t (FetchOptions -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveFetchOptionsMethod t FetchOptions, O.MethodInfo info FetchOptions p) => O.IsLabel t (FetchOptions -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif