{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.OSTree.Interfaces.RepoFinder
    ( 

-- * Exported types
    RepoFinder(..)                          ,
    IsRepoFinder                            ,
    toRepoFinder                            ,


 -- * 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"), [resolveAsync]("GI.OSTree.Interfaces.RepoFinder#g:method:resolveAsync"), [resolveFinish]("GI.OSTree.Interfaces.RepoFinder#g:method:resolveFinish"), [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"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveRepoFinderMethod                 ,
#endif

-- ** resolveAllAsync #method:resolveAllAsync#

    repoFinderResolveAllAsync               ,


-- ** resolveAllFinish #method:resolveAllFinish#

    repoFinderResolveAllFinish              ,


-- ** resolveAsync #method:resolveAsync#

#if defined(ENABLE_OVERLOADING)
    RepoFinderResolveAsyncMethodInfo        ,
#endif
    repoFinderResolveAsync                  ,


-- ** resolveFinish #method:resolveFinish#

#if defined(ENABLE_OVERLOADING)
    RepoFinderResolveFinishMethodInfo       ,
#endif
    repoFinderResolveFinish                 ,




    ) 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.GHashTable as B.GHT
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.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.KeyFile as GLib.KeyFile
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GLib.Structs.VariantDict as GLib.VariantDict
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
import qualified GI.OSTree.Callbacks as OSTree.Callbacks
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags
import {-# SOURCE #-} qualified GI.OSTree.Interfaces.BlobReader as OSTree.BlobReader
import {-# SOURCE #-} qualified GI.OSTree.Interfaces.Sign as OSTree.Sign
import {-# SOURCE #-} qualified GI.OSTree.Objects.AsyncProgress as OSTree.AsyncProgress
import {-# SOURCE #-} qualified GI.OSTree.Objects.ContentWriter as OSTree.ContentWriter
import {-# SOURCE #-} qualified GI.OSTree.Objects.GpgVerifyResult as OSTree.GpgVerifyResult
import {-# SOURCE #-} qualified GI.OSTree.Objects.MutableTree as OSTree.MutableTree
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
import {-# SOURCE #-} qualified GI.OSTree.Objects.RepoFile as OSTree.RepoFile
import {-# SOURCE #-} qualified GI.OSTree.Objects.SePolicy as OSTree.SePolicy
import {-# SOURCE #-} qualified GI.OSTree.Structs.CollectionRef as OSTree.CollectionRef
import {-# SOURCE #-} qualified GI.OSTree.Structs.Remote as OSTree.Remote
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoCheckoutAtOptions as OSTree.RepoCheckoutAtOptions
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoCommitModifier as OSTree.RepoCommitModifier
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoDevInoCache as OSTree.RepoDevInoCache
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoFinderResult as OSTree.RepoFinderResult
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoPruneOptions as OSTree.RepoPruneOptions
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoTransactionStats as OSTree.RepoTransactionStats

#else
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
import {-# SOURCE #-} qualified GI.OSTree.Structs.CollectionRef as OSTree.CollectionRef
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoFinderResult as OSTree.RepoFinderResult

#endif

-- interface RepoFinder 
-- | Memory-managed wrapper type.
newtype RepoFinder = RepoFinder (SP.ManagedPtr RepoFinder)
    deriving (RepoFinder -> RepoFinder -> Bool
(RepoFinder -> RepoFinder -> Bool)
-> (RepoFinder -> RepoFinder -> Bool) -> Eq RepoFinder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoFinder -> RepoFinder -> Bool
== :: RepoFinder -> RepoFinder -> Bool
$c/= :: RepoFinder -> RepoFinder -> Bool
/= :: RepoFinder -> RepoFinder -> Bool
Eq)

instance SP.ManagedPtrNewtype RepoFinder where
    toManagedPtr :: RepoFinder -> ManagedPtr RepoFinder
toManagedPtr (RepoFinder ManagedPtr RepoFinder
p) = ManagedPtr RepoFinder
p

foreign import ccall "ostree_repo_finder_get_type"
    c_ostree_repo_finder_get_type :: IO B.Types.GType

instance B.Types.TypedObject RepoFinder where
    glibType :: IO GType
glibType = IO GType
c_ostree_repo_finder_get_type

instance B.Types.GObject RepoFinder

-- | Type class for types which can be safely cast to t'RepoFinder', for instance with `toRepoFinder`.
class (SP.GObject o, O.IsDescendantOf RepoFinder o) => IsRepoFinder o
instance (SP.GObject o, O.IsDescendantOf RepoFinder o) => IsRepoFinder o

instance O.HasParentTypes RepoFinder
type instance O.ParentTypes RepoFinder = '[GObject.Object.Object]

-- | Cast to t'RepoFinder', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
toRepoFinder :: (MIO.MonadIO m, IsRepoFinder o) => o -> m RepoFinder
toRepoFinder :: forall (m :: * -> *) o.
(MonadIO m, IsRepoFinder o) =>
o -> m RepoFinder
toRepoFinder = IO RepoFinder -> m RepoFinder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO RepoFinder -> m RepoFinder)
-> (o -> IO RepoFinder) -> o -> m RepoFinder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr RepoFinder -> RepoFinder) -> o -> IO RepoFinder
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr RepoFinder -> RepoFinder
RepoFinder

-- | Convert t'RepoFinder' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe RepoFinder) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ostree_repo_finder_get_type
    gvalueSet_ :: Ptr GValue -> Maybe RepoFinder -> IO ()
gvalueSet_ Ptr GValue
gv Maybe RepoFinder
P.Nothing = Ptr GValue -> Ptr RepoFinder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr RepoFinder
forall a. Ptr a
FP.nullPtr :: FP.Ptr RepoFinder)
    gvalueSet_ Ptr GValue
gv (P.Just RepoFinder
obj) = RepoFinder -> (Ptr RepoFinder -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RepoFinder
obj (Ptr GValue -> Ptr RepoFinder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe RepoFinder)
gvalueGet_ Ptr GValue
gv = do
        ptr <- Ptr GValue -> IO (Ptr RepoFinder)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr RepoFinder)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newObject RepoFinder ptr
        else return P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RepoFinder
type instance O.AttributeList RepoFinder = RepoFinderAttributeList
type RepoFinderAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveRepoFinderMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveRepoFinderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveRepoFinderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveRepoFinderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveRepoFinderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveRepoFinderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveRepoFinderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveRepoFinderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveRepoFinderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveRepoFinderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveRepoFinderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveRepoFinderMethod "resolveAsync" o = RepoFinderResolveAsyncMethodInfo
    ResolveRepoFinderMethod "resolveFinish" o = RepoFinderResolveFinishMethodInfo
    ResolveRepoFinderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveRepoFinderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveRepoFinderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveRepoFinderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveRepoFinderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveRepoFinderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveRepoFinderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveRepoFinderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveRepoFinderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveRepoFinderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveRepoFinderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveRepoFinderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveRepoFinderMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveRepoFinderMethod t RepoFinder, O.OverloadedMethod info RepoFinder p) => OL.IsLabel t (RepoFinder -> 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 ~ ResolveRepoFinderMethod t RepoFinder, O.OverloadedMethod info RepoFinder p, R.HasField t RepoFinder p) => R.HasField t RepoFinder p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveRepoFinderMethod t RepoFinder, O.OverloadedMethodInfo info RepoFinder) => OL.IsLabel t (O.MethodProxy info RepoFinder) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- method RepoFinder::resolve_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoFinder" }
--           , argCType = Just "OstreeRepoFinder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepoFinder"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "refs"
--           , argType =
--               TCArray
--                 True
--                 (-1)
--                 (-1)
--                 (TInterface Name { namespace = "OSTree" , name = "CollectionRef" })
--           , argCType = Just "const OstreeCollectionRef* const*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "non-empty array of collection\8211ref pairs to find remotes for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent_repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , argCType = Just "OstreeRepo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the local repository which the refs are being resolved for,\n   which provides configuration information and GPG keys"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , argCType = Just "GCancellable*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , argCType = Just "GAsyncReadyCallback"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "asynchronous completion callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 5
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , argCType = Just "gpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to pass to @callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_finder_resolve_async" ostree_repo_finder_resolve_async :: 
    Ptr RepoFinder ->                       -- self : TInterface (Name {namespace = "OSTree", name = "RepoFinder"})
    Ptr (Ptr OSTree.CollectionRef.CollectionRef) -> -- refs : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"}))
    Ptr OSTree.Repo.Repo ->                 -- parent_repo : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Find reachable remote URIs which claim to provide any of the given /@refs@/. The
-- specific method for finding the remotes depends on the t'GI.OSTree.Interfaces.RepoFinder.RepoFinder'
-- implementation.
-- 
-- Any remote which is found and which claims to support any of the given /@refs@/
-- will be returned in the results. It is possible that a remote claims to
-- support a given ref, but turns out not to — it is not possible to verify this
-- until 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' is called.
-- 
-- The returned results will be sorted with the most useful first — this is
-- typically the remote which claims to provide the most /@refs@/, at the lowest
-- latency.
-- 
-- Each result contains a mapping of /@refs@/ to the checksums of the commits
-- which the result provides. If the result provides the latest commit for a ref
-- across all of the results, the checksum will be set. Otherwise, if the
-- result provides an outdated commit, or doesn’t provide a given ref at all,
-- the checksum will not be set. Results which provide none of the requested
-- /@refs@/ may be listed with an empty refs map.
-- 
-- Pass the results to 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' to pull the given
-- /@refs@/ from those remotes.
-- 
-- /Since: 2018.6/
repoFinderResolveAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepoFinder a, OSTree.Repo.IsRepo b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Interfaces.RepoFinder.RepoFinder'
    -> [OSTree.CollectionRef.CollectionRef]
    -- ^ /@refs@/: non-empty array of collection–ref pairs to find remotes for
    -> b
    -- ^ /@parentRepo@/: the local repository which the refs are being resolved for,
    --    which provides configuration information and GPG keys
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: asynchronous completion callback
    -> m ()
repoFinderResolveAsync :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepoFinder a, IsRepo b,
 IsCancellable c) =>
a
-> [CollectionRef]
-> b
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
repoFinderResolveAsync a
self [CollectionRef]
refs b
parentRepo Maybe c
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    self' <- a -> IO (Ptr RepoFinder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    refs' <- mapM unsafeManagedPtrGetPtr refs
    refs'' <- packZeroTerminatedPtrArray refs'
    parentRepo' <- unsafeManagedPtrCastPtr parentRepo
    maybeCancellable <- case cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just c
jCancellable -> do
            jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
forall a. FunPtr a
FP.nullFunPtr
        Just AsyncReadyCallback
jCallback -> do
            ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = Ptr a
forall a. Ptr a
nullPtr
    ostree_repo_finder_resolve_async self' refs'' parentRepo' maybeCancellable maybeCallback userData
    touchManagedPtr self
    mapM_ touchManagedPtr refs
    touchManagedPtr parentRepo
    whenJust cancellable touchManagedPtr
    freeMem refs''
    return ()

#if defined(ENABLE_OVERLOADING)
data RepoFinderResolveAsyncMethodInfo
instance (signature ~ ([OSTree.CollectionRef.CollectionRef] -> b -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepoFinder a, OSTree.Repo.IsRepo b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoFinderResolveAsyncMethodInfo a signature where
    overloadedMethod = repoFinderResolveAsync

instance O.OverloadedMethodInfo RepoFinderResolveAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Interfaces-RepoFinder.html#v:repoFinderResolveAsync"
        })


#endif

-- method RepoFinder::resolve_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoFinder" }
--           , argCType = Just "OstreeRepoFinder*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepoFinder"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , argCType = Just "GAsyncResult*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GAsyncResult from the callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TPtrArray
--                  (TInterface
--                     Name { namespace = "OSTree" , name = "RepoFinderResult" }))
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_finder_resolve_finish" ostree_repo_finder_resolve_finish :: 
    Ptr RepoFinder ->                       -- self : TInterface (Name {namespace = "OSTree", name = "RepoFinder"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GPtrArray (Ptr OSTree.RepoFinderResult.RepoFinderResult)))

-- | Get the results from a 'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync' operation.
-- 
-- /Since: 2018.6/
repoFinderResolveFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepoFinder a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Interfaces.RepoFinder.RepoFinder'
    -> b
    -- ^ /@result@/: t'GI.Gio.Interfaces.AsyncResult.AsyncResult' from the callback
    -> m [OSTree.RepoFinderResult.RepoFinderResult]
    -- ^ __Returns:__ array of zero
    --    or more results /(Can throw 'Data.GI.Base.GError.GError')/
repoFinderResolveFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepoFinder a, IsAsyncResult b) =>
a -> b -> m [RepoFinderResult]
repoFinderResolveFinish a
self b
result_ = IO [RepoFinderResult] -> m [RepoFinderResult]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [RepoFinderResult] -> m [RepoFinderResult])
-> IO [RepoFinderResult] -> m [RepoFinderResult]
forall a b. (a -> b) -> a -> b
$ do
    self' <- a -> IO (Ptr RepoFinder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ ostree_repo_finder_resolve_finish self' result_'
        checkUnexpectedReturnNULL "repoFinderResolveFinish" result
        result' <- unpackGPtrArray result
        result'' <- mapM (wrapBoxed OSTree.RepoFinderResult.RepoFinderResult) result'
        unrefPtrArray result
        touchManagedPtr self
        touchManagedPtr result_
        return result''
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoFinderResolveFinishMethodInfo
instance (signature ~ (b -> m [OSTree.RepoFinderResult.RepoFinderResult]), MonadIO m, IsRepoFinder a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod RepoFinderResolveFinishMethodInfo a signature where
    overloadedMethod = repoFinderResolveFinish

instance O.OverloadedMethodInfo RepoFinderResolveFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Interfaces.RepoFinder.repoFinderResolveFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.19/docs/GI-OSTree-Interfaces-RepoFinder.html#v:repoFinderResolveFinish"
        })


#endif

-- method RepoFinder::resolve_all_async
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "finders"
--           , argType =
--               TCArray
--                 True
--                 (-1)
--                 (-1)
--                 (TInterface Name { namespace = "OSTree" , name = "RepoFinder" })
--           , argCType = Just "OstreeRepoFinder* const*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "non-empty array of #OstreeRepoFinders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "refs"
--           , argType =
--               TCArray
--                 True
--                 (-1)
--                 (-1)
--                 (TInterface Name { namespace = "OSTree" , name = "CollectionRef" })
--           , argCType = Just "const OstreeCollectionRef* const*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "non-empty array of collection\8211ref pairs to find remotes for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent_repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , argCType = Just "OstreeRepo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the local repository which the refs are being resolved for,\n   which provides configuration information and GPG keys"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , argCType = Just "GCancellable*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , argCType = Just "GAsyncReadyCallback"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "asynchronous completion callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 5
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , argCType = Just "gpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to pass to @callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_finder_resolve_all_async" ostree_repo_finder_resolve_all_async :: 
    Ptr (Ptr RepoFinder) ->                 -- finders : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinder"}))
    Ptr (Ptr OSTree.CollectionRef.CollectionRef) -> -- refs : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"}))
    Ptr OSTree.Repo.Repo ->                 -- parent_repo : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | A version of 'GI.OSTree.Interfaces.RepoFinder.repoFinderResolveAsync' which queries one or more
-- /@finders@/ in parallel and combines the results.
-- 
-- /Since: 2018.6/
repoFinderResolveAllAsync ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) =>
    [RepoFinder]
    -- ^ /@finders@/: non-empty array of @/OstreeRepoFinders/@
    -> [OSTree.CollectionRef.CollectionRef]
    -- ^ /@refs@/: non-empty array of collection–ref pairs to find remotes for
    -> a
    -- ^ /@parentRepo@/: the local repository which the refs are being resolved for,
    --    which provides configuration information and GPG keys
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: asynchronous completion callback
    -> m ()
repoFinderResolveAllAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
[RepoFinder]
-> [CollectionRef]
-> a
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
repoFinderResolveAllAsync [RepoFinder]
finders [CollectionRef]
refs a
parentRepo Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    finders' <- (RepoFinder -> IO (Ptr RepoFinder))
-> [RepoFinder] -> IO [Ptr RepoFinder]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM RepoFinder -> IO (Ptr RepoFinder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [RepoFinder]
finders
    finders'' <- packZeroTerminatedPtrArray finders'
    refs' <- mapM unsafeManagedPtrGetPtr refs
    refs'' <- packZeroTerminatedPtrArray refs'
    parentRepo' <- unsafeManagedPtrCastPtr parentRepo
    maybeCancellable <- case cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
        Just b
jCancellable -> do
            jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
forall a. FunPtr a
FP.nullFunPtr
        Just AsyncReadyCallback
jCallback -> do
            ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = Ptr a
forall a. Ptr a
nullPtr
    ostree_repo_finder_resolve_all_async finders'' refs'' parentRepo' maybeCancellable maybeCallback userData
    mapM_ touchManagedPtr finders
    mapM_ touchManagedPtr refs
    touchManagedPtr parentRepo
    whenJust cancellable touchManagedPtr
    freeMem finders''
    freeMem refs''
    return ()

#if defined(ENABLE_OVERLOADING)
#endif

-- method RepoFinder::resolve_all_finish
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , argCType = Just "GAsyncResult*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GAsyncResult from the callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TPtrArray
--                  (TInterface
--                     Name { namespace = "OSTree" , name = "RepoFinderResult" }))
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_finder_resolve_all_finish" ostree_repo_finder_resolve_all_finish :: 
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GPtrArray (Ptr OSTree.RepoFinderResult.RepoFinderResult)))

-- | Get the results from a 'GI.OSTree.Functions.repoFinderResolveAllAsync' operation.
-- 
-- /Since: 2018.6/
repoFinderResolveAllFinish ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
    a
    -- ^ /@result@/: t'GI.Gio.Interfaces.AsyncResult.AsyncResult' from the callback
    -> m [OSTree.RepoFinderResult.RepoFinderResult]
    -- ^ __Returns:__ array of zero
    --    or more results /(Can throw 'Data.GI.Base.GError.GError')/
repoFinderResolveAllFinish :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncResult a) =>
a -> m [RepoFinderResult]
repoFinderResolveAllFinish a
result_ = IO [RepoFinderResult] -> m [RepoFinderResult]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [RepoFinderResult] -> m [RepoFinderResult])
-> IO [RepoFinderResult] -> m [RepoFinderResult]
forall a b. (a -> b) -> a -> b
$ do
    result_' <- a -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
result_
    onException (do
        result <- propagateGError $ ostree_repo_finder_resolve_all_finish result_'
        checkUnexpectedReturnNULL "repoFinderResolveAllFinish" result
        result' <- unpackGPtrArray result
        result'' <- mapM (wrapBoxed OSTree.RepoFinderResult.RepoFinderResult) result'
        unrefPtrArray result
        touchManagedPtr result_
        return result''
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList RepoFinder = RepoFinderSignalList
type RepoFinderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif