-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.OSTree.Callbacks
    ( 

 -- * Signals


-- ** RepoCheckoutFilter #signal:RepoCheckoutFilter#

    C_RepoCheckoutFilter                    ,
    RepoCheckoutFilter                      ,
    RepoCheckoutFilter_WithClosures         ,
    drop_closures_RepoCheckoutFilter        ,
    dynamic_RepoCheckoutFilter              ,
    genClosure_RepoCheckoutFilter           ,
    mk_RepoCheckoutFilter                   ,
    noRepoCheckoutFilter                    ,
    noRepoCheckoutFilter_WithClosures       ,
    wrap_RepoCheckoutFilter                 ,


-- ** RepoCommitFilter #signal:RepoCommitFilter#

    C_RepoCommitFilter                      ,
    RepoCommitFilter                        ,
    RepoCommitFilter_WithClosures           ,
    drop_closures_RepoCommitFilter          ,
    dynamic_RepoCommitFilter                ,
    genClosure_RepoCommitFilter             ,
    mk_RepoCommitFilter                     ,
    noRepoCommitFilter                      ,
    noRepoCommitFilter_WithClosures         ,
    wrap_RepoCommitFilter                   ,


-- ** RepoCommitModifierXattrCallback #signal:RepoCommitModifierXattrCallback#

    C_RepoCommitModifierXattrCallback       ,
    RepoCommitModifierXattrCallback         ,
    RepoCommitModifierXattrCallback_WithClosures,
    drop_closures_RepoCommitModifierXattrCallback,
    dynamic_RepoCommitModifierXattrCallback ,
    genClosure_RepoCommitModifierXattrCallback,
    mk_RepoCommitModifierXattrCallback      ,
    noRepoCommitModifierXattrCallback       ,
    noRepoCommitModifierXattrCallback_WithClosures,
    wrap_RepoCommitModifierXattrCallback    ,


-- ** RepoImportArchiveTranslatePathname #signal:RepoImportArchiveTranslatePathname#

    C_RepoImportArchiveTranslatePathname    ,
    RepoImportArchiveTranslatePathname      ,
    RepoImportArchiveTranslatePathname_WithClosures,
    drop_closures_RepoImportArchiveTranslatePathname,
    dynamic_RepoImportArchiveTranslatePathname,
    genClosure_RepoImportArchiveTranslatePathname,
    mk_RepoImportArchiveTranslatePathname   ,
    noRepoImportArchiveTranslatePathname    ,
    noRepoImportArchiveTranslatePathname_WithClosures,
    wrap_RepoImportArchiveTranslatePathname ,




    ) 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 {-# 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.RepoFinder as OSTree.RepoFinder
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.Gio.Objects.FileInfo as Gio.FileInfo
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo

#endif

-- callback RepoImportArchiveTranslatePathname
{- Callable
  { returnType = Just (TBasicType TUTF8)
  , returnMayBeNull = False
  , returnTransfer = TransferEverything
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "repo"
          , argType =
              TInterface Name { namespace = "OSTree" , name = "Repo" }
          , argCType = Just "OstreeRepo*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Just "Repo" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "stbuf"
          , argType = TBasicType TPtr
          , argCType = Just "const stat*"
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "Stat buffer" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "src_path"
          , argType = TBasicType TUTF8
          , argCType = Just "const char*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "Path in the archive"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , 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 "User data" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "Possibly change a pathname while importing an archive. If %NULL is returned,\nthen @src_path will be used unchanged.  Otherwise, return a new pathname which\nwill be freed via `g_free()`.\n\nThis pathname translation will be performed *before* any processing from an\nactive `OstreeRepoCommitModifier`. Will be invoked for all directory and file\ntypes, first with outer directories, then their sub-files and directories.\n\nNote that enabling pathname translation will always override the setting for\n`use_ostree_convention`."
        , sinceVersion = Just "2017.11"
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_RepoImportArchiveTranslatePathname =
    Ptr OSTree.Repo.Repo ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO CString

-- Args: [ Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , argCType = Just "OstreeRepo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stbuf"
--           , argType = TBasicType TPtr
--           , argCType = Just "const stat*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Stat buffer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "src_path"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path in the archive"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , 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 "User data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_RepoImportArchiveTranslatePathname :: FunPtr C_RepoImportArchiveTranslatePathname -> C_RepoImportArchiveTranslatePathname

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_RepoImportArchiveTranslatePathname ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
    FunPtr C_RepoImportArchiveTranslatePathname
    -> a
    -- ^ /@repo@/: Repo
    -> Ptr ()
    -- ^ /@stbuf@/: Stat buffer
    -> T.Text
    -- ^ /@srcPath@/: Path in the archive
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> m T.Text
dynamic_RepoImportArchiveTranslatePathname :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
FunPtr C_RepoImportArchiveTranslatePathname
-> a -> Ptr () -> Text -> Ptr () -> m Text
dynamic_RepoImportArchiveTranslatePathname FunPtr C_RepoImportArchiveTranslatePathname
__funPtr a
repo Ptr ()
stbuf Text
srcPath Ptr ()
userData = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    repo' <- a -> IO (Ptr Repo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    srcPath' <- textToCString srcPath
    result <- (__dynamic_C_RepoImportArchiveTranslatePathname __funPtr) repo' stbuf srcPath' userData
    checkUnexpectedReturnNULL "repoImportArchiveTranslatePathname" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr repo
    freeMem srcPath'
    return result'

-- | Generate a function pointer callable from C code, from a `C_RepoImportArchiveTranslatePathname`.
foreign import ccall "wrapper"
    mk_RepoImportArchiveTranslatePathname :: C_RepoImportArchiveTranslatePathname -> IO (FunPtr C_RepoImportArchiveTranslatePathname)

-- | Possibly change a pathname while importing an archive. If 'P.Nothing' is returned,
-- then /@srcPath@/ will be used unchanged.  Otherwise, return a new pathname which
-- will be freed via @g_free()@.
-- 
-- This pathname translation will be performed *before* any processing from an
-- active @OstreeRepoCommitModifier@. Will be invoked for all directory and file
-- types, first with outer directories, then their sub-files and directories.
-- 
-- Note that enabling pathname translation will always override the setting for
-- @use_ostree_convention@.
-- 
-- /Since: 2017.11/
type RepoImportArchiveTranslatePathname =
    OSTree.Repo.Repo
    -- ^ /@repo@/: Repo
    -> Ptr ()
    -- ^ /@stbuf@/: Stat buffer
    -> T.Text
    -- ^ /@srcPath@/: Path in the archive
    -> IO T.Text

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoImportArchiveTranslatePathname`@.
noRepoImportArchiveTranslatePathname :: Maybe RepoImportArchiveTranslatePathname
noRepoImportArchiveTranslatePathname :: Maybe RepoImportArchiveTranslatePathname
noRepoImportArchiveTranslatePathname = Maybe RepoImportArchiveTranslatePathname
forall a. Maybe a
Nothing

-- | Possibly change a pathname while importing an archive. If 'P.Nothing' is returned,
-- then /@srcPath@/ will be used unchanged.  Otherwise, return a new pathname which
-- will be freed via @g_free()@.
-- 
-- This pathname translation will be performed *before* any processing from an
-- active @OstreeRepoCommitModifier@. Will be invoked for all directory and file
-- types, first with outer directories, then their sub-files and directories.
-- 
-- Note that enabling pathname translation will always override the setting for
-- @use_ostree_convention@.
-- 
-- /Since: 2017.11/
type RepoImportArchiveTranslatePathname_WithClosures =
    OSTree.Repo.Repo
    -- ^ /@repo@/: Repo
    -> Ptr ()
    -- ^ /@stbuf@/: Stat buffer
    -> T.Text
    -- ^ /@srcPath@/: Path in the archive
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> IO T.Text

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoImportArchiveTranslatePathname_WithClosures`@.
noRepoImportArchiveTranslatePathname_WithClosures :: Maybe RepoImportArchiveTranslatePathname_WithClosures
noRepoImportArchiveTranslatePathname_WithClosures :: Maybe RepoImportArchiveTranslatePathname_WithClosures
noRepoImportArchiveTranslatePathname_WithClosures = Maybe RepoImportArchiveTranslatePathname_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoImportArchiveTranslatePathname :: RepoImportArchiveTranslatePathname -> RepoImportArchiveTranslatePathname_WithClosures
drop_closures_RepoImportArchiveTranslatePathname :: RepoImportArchiveTranslatePathname
-> RepoImportArchiveTranslatePathname_WithClosures
drop_closures_RepoImportArchiveTranslatePathname RepoImportArchiveTranslatePathname
_f Repo
repo Ptr ()
stbuf Text
srcPath Ptr ()
_ = RepoImportArchiveTranslatePathname
_f Repo
repo Ptr ()
stbuf Text
srcPath

-- | Wrap the callback into a `GClosure`.
genClosure_RepoImportArchiveTranslatePathname :: MonadIO m => RepoImportArchiveTranslatePathname -> m (GClosure C_RepoImportArchiveTranslatePathname)
genClosure_RepoImportArchiveTranslatePathname :: forall (m :: * -> *).
MonadIO m =>
RepoImportArchiveTranslatePathname
-> m (GClosure C_RepoImportArchiveTranslatePathname)
genClosure_RepoImportArchiveTranslatePathname RepoImportArchiveTranslatePathname
cb = IO (GClosure C_RepoImportArchiveTranslatePathname)
-> m (GClosure C_RepoImportArchiveTranslatePathname)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RepoImportArchiveTranslatePathname)
 -> m (GClosure C_RepoImportArchiveTranslatePathname))
-> IO (GClosure C_RepoImportArchiveTranslatePathname)
-> m (GClosure C_RepoImportArchiveTranslatePathname)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: RepoImportArchiveTranslatePathname_WithClosures
cb' = RepoImportArchiveTranslatePathname
-> RepoImportArchiveTranslatePathname_WithClosures
drop_closures_RepoImportArchiveTranslatePathname RepoImportArchiveTranslatePathname
cb
    let cb'' :: C_RepoImportArchiveTranslatePathname
cb'' = Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname))
-> RepoImportArchiveTranslatePathname_WithClosures
-> C_RepoImportArchiveTranslatePathname
wrap_RepoImportArchiveTranslatePathname Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname))
forall a. Maybe a
Nothing RepoImportArchiveTranslatePathname_WithClosures
cb'
    C_RepoImportArchiveTranslatePathname
-> IO (FunPtr C_RepoImportArchiveTranslatePathname)
mk_RepoImportArchiveTranslatePathname C_RepoImportArchiveTranslatePathname
cb'' IO (FunPtr C_RepoImportArchiveTranslatePathname)
-> (FunPtr C_RepoImportArchiveTranslatePathname
    -> IO (GClosure C_RepoImportArchiveTranslatePathname))
-> IO (GClosure C_RepoImportArchiveTranslatePathname)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RepoImportArchiveTranslatePathname
-> IO (GClosure C_RepoImportArchiveTranslatePathname)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `RepoImportArchiveTranslatePathname` into a `C_RepoImportArchiveTranslatePathname`.
wrap_RepoImportArchiveTranslatePathname :: 
    Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname)) ->
    RepoImportArchiveTranslatePathname_WithClosures ->
    C_RepoImportArchiveTranslatePathname
wrap_RepoImportArchiveTranslatePathname :: Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname))
-> RepoImportArchiveTranslatePathname_WithClosures
-> C_RepoImportArchiveTranslatePathname
wrap_RepoImportArchiveTranslatePathname Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname))
gi'funptrptr RepoImportArchiveTranslatePathname_WithClosures
gi'cb Ptr Repo
repo Ptr ()
stbuf CString
srcPath Ptr ()
userData = do
    repo' <- ((ManagedPtr Repo -> Repo) -> Ptr Repo -> IO Repo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
OSTree.Repo.Repo) Ptr Repo
repo
    srcPath' <- cstringToText srcPath
    result <- gi'cb  repo' stbuf srcPath' userData
    maybeReleaseFunPtr gi'funptrptr
    result' <- textToCString result
    return result'


-- callback RepoCommitModifierXattrCallback
{- Callable
  { returnType = Just TVariant
  , returnMayBeNull = False
  , returnTransfer = TransferEverything
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "repo"
          , argType =
              TInterface Name { namespace = "OSTree" , name = "Repo" }
          , argCType = Just "OstreeRepo*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "path"
          , argType = TBasicType TUTF8
          , argCType = Just "const char*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "file_info"
          , argType =
              TInterface Name { namespace = "Gio" , name = "FileInfo" }
          , argCType = Just "GFileInfo*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , 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 = Nothing , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_RepoCommitModifierXattrCallback =
    Ptr OSTree.Repo.Repo ->
    CString ->
    Ptr Gio.FileInfo.FileInfo ->
    Ptr () ->
    IO (Ptr GVariant)

-- Args: [ Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , argCType = Just "OstreeRepo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "file_info"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "FileInfo" }
--           , argCType = Just "GFileInfo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , 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 = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_RepoCommitModifierXattrCallback :: FunPtr C_RepoCommitModifierXattrCallback -> C_RepoCommitModifierXattrCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_RepoCommitModifierXattrCallback ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.FileInfo.IsFileInfo b) =>
    FunPtr C_RepoCommitModifierXattrCallback
    -> a
    -> T.Text
    -> b
    -> Ptr ()
    -> m GVariant
dynamic_RepoCommitModifierXattrCallback :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsFileInfo b) =>
FunPtr C_RepoCommitModifierXattrCallback
-> a -> Text -> b -> Ptr () -> m GVariant
dynamic_RepoCommitModifierXattrCallback FunPtr C_RepoCommitModifierXattrCallback
__funPtr a
repo Text
path b
fileInfo Ptr ()
userData = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
    repo' <- a -> IO (Ptr Repo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    path' <- textToCString path
    fileInfo' <- unsafeManagedPtrCastPtr fileInfo
    result <- (__dynamic_C_RepoCommitModifierXattrCallback __funPtr) repo' path' fileInfo' userData
    checkUnexpectedReturnNULL "repoCommitModifierXattrCallback" result
    result' <- B.GVariant.wrapGVariantPtr result
    touchManagedPtr repo
    touchManagedPtr fileInfo
    freeMem path'
    return result'

-- | Generate a function pointer callable from C code, from a `C_RepoCommitModifierXattrCallback`.
foreign import ccall "wrapper"
    mk_RepoCommitModifierXattrCallback :: C_RepoCommitModifierXattrCallback -> IO (FunPtr C_RepoCommitModifierXattrCallback)

-- | /No description available in the introspection data./
type RepoCommitModifierXattrCallback =
    OSTree.Repo.Repo
    -> T.Text
    -> Gio.FileInfo.FileInfo
    -> IO GVariant

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitModifierXattrCallback`@.
noRepoCommitModifierXattrCallback :: Maybe RepoCommitModifierXattrCallback
noRepoCommitModifierXattrCallback :: Maybe RepoCommitModifierXattrCallback
noRepoCommitModifierXattrCallback = Maybe RepoCommitModifierXattrCallback
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type RepoCommitModifierXattrCallback_WithClosures =
    OSTree.Repo.Repo
    -> T.Text
    -> Gio.FileInfo.FileInfo
    -> Ptr ()
    -> IO GVariant

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitModifierXattrCallback_WithClosures`@.
noRepoCommitModifierXattrCallback_WithClosures :: Maybe RepoCommitModifierXattrCallback_WithClosures
noRepoCommitModifierXattrCallback_WithClosures :: Maybe RepoCommitModifierXattrCallback_WithClosures
noRepoCommitModifierXattrCallback_WithClosures = Maybe RepoCommitModifierXattrCallback_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCommitModifierXattrCallback :: RepoCommitModifierXattrCallback -> RepoCommitModifierXattrCallback_WithClosures
drop_closures_RepoCommitModifierXattrCallback :: RepoCommitModifierXattrCallback
-> RepoCommitModifierXattrCallback_WithClosures
drop_closures_RepoCommitModifierXattrCallback RepoCommitModifierXattrCallback
_f Repo
repo Text
path FileInfo
fileInfo Ptr ()
_ = RepoCommitModifierXattrCallback
_f Repo
repo Text
path FileInfo
fileInfo

-- | Wrap the callback into a `GClosure`.
genClosure_RepoCommitModifierXattrCallback :: MonadIO m => RepoCommitModifierXattrCallback -> m (GClosure C_RepoCommitModifierXattrCallback)
genClosure_RepoCommitModifierXattrCallback :: forall (m :: * -> *).
MonadIO m =>
RepoCommitModifierXattrCallback
-> m (GClosure C_RepoCommitModifierXattrCallback)
genClosure_RepoCommitModifierXattrCallback RepoCommitModifierXattrCallback
cb = IO (GClosure C_RepoCommitModifierXattrCallback)
-> m (GClosure C_RepoCommitModifierXattrCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RepoCommitModifierXattrCallback)
 -> m (GClosure C_RepoCommitModifierXattrCallback))
-> IO (GClosure C_RepoCommitModifierXattrCallback)
-> m (GClosure C_RepoCommitModifierXattrCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: RepoCommitModifierXattrCallback_WithClosures
cb' = RepoCommitModifierXattrCallback
-> RepoCommitModifierXattrCallback_WithClosures
drop_closures_RepoCommitModifierXattrCallback RepoCommitModifierXattrCallback
cb
    let cb'' :: C_RepoCommitModifierXattrCallback
cb'' = Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
-> RepoCommitModifierXattrCallback_WithClosures
-> C_RepoCommitModifierXattrCallback
wrap_RepoCommitModifierXattrCallback Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
forall a. Maybe a
Nothing RepoCommitModifierXattrCallback_WithClosures
cb'
    C_RepoCommitModifierXattrCallback
-> IO (FunPtr C_RepoCommitModifierXattrCallback)
mk_RepoCommitModifierXattrCallback C_RepoCommitModifierXattrCallback
cb'' IO (FunPtr C_RepoCommitModifierXattrCallback)
-> (FunPtr C_RepoCommitModifierXattrCallback
    -> IO (GClosure C_RepoCommitModifierXattrCallback))
-> IO (GClosure C_RepoCommitModifierXattrCallback)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RepoCommitModifierXattrCallback
-> IO (GClosure C_RepoCommitModifierXattrCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `RepoCommitModifierXattrCallback` into a `C_RepoCommitModifierXattrCallback`.
wrap_RepoCommitModifierXattrCallback :: 
    Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback)) ->
    RepoCommitModifierXattrCallback_WithClosures ->
    C_RepoCommitModifierXattrCallback
wrap_RepoCommitModifierXattrCallback :: Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
-> RepoCommitModifierXattrCallback_WithClosures
-> C_RepoCommitModifierXattrCallback
wrap_RepoCommitModifierXattrCallback Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback))
gi'funptrptr RepoCommitModifierXattrCallback_WithClosures
gi'cb Ptr Repo
repo CString
path Ptr FileInfo
fileInfo Ptr ()
userData = do
    repo' <- ((ManagedPtr Repo -> Repo) -> Ptr Repo -> IO Repo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
OSTree.Repo.Repo) Ptr Repo
repo
    path' <- cstringToText path
    fileInfo' <- (newObject Gio.FileInfo.FileInfo) fileInfo
    result <- gi'cb  repo' path' fileInfo' userData
    maybeReleaseFunPtr gi'funptrptr
    result' <- B.GVariant.disownGVariant result
    return result'


-- callback RepoCommitFilter
{- Callable
  { returnType =
      Just
        (TInterface
           Name { namespace = "OSTree" , name = "RepoCommitFilterResult" })
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "#OstreeRepoCommitFilterResult saying whether or not to commit this file"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "repo"
          , argType =
              TInterface Name { namespace = "OSTree" , name = "Repo" }
          , argCType = Just "OstreeRepo*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Just "Repo" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "path"
          , argType = TBasicType TUTF8
          , argCType = Just "const char*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "Path to file" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "file_info"
          , argType =
              TInterface Name { namespace = "Gio" , name = "FileInfo" }
          , argCType = Just "GFileInfo*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "File information" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , 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 "User data" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_RepoCommitFilter =
    Ptr OSTree.Repo.Repo ->
    CString ->
    Ptr Gio.FileInfo.FileInfo ->
    Ptr () ->
    IO CUInt

-- Args: [ Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , argCType = Just "OstreeRepo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path to file" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "file_info"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "FileInfo" }
--           , argCType = Just "GFileInfo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "File information" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , 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 "User data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "OSTree" , name = "RepoCommitFilterResult" })
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_RepoCommitFilter :: FunPtr C_RepoCommitFilter -> C_RepoCommitFilter

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_RepoCommitFilter ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.FileInfo.IsFileInfo b) =>
    FunPtr C_RepoCommitFilter
    -> a
    -- ^ /@repo@/: Repo
    -> T.Text
    -- ^ /@path@/: Path to file
    -> b
    -- ^ /@fileInfo@/: File information
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> m OSTree.Enums.RepoCommitFilterResult
    -- ^ __Returns:__ t'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file
dynamic_RepoCommitFilter :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsFileInfo b) =>
FunPtr C_RepoCommitFilter
-> a -> Text -> b -> Ptr () -> m RepoCommitFilterResult
dynamic_RepoCommitFilter FunPtr C_RepoCommitFilter
__funPtr a
repo Text
path b
fileInfo Ptr ()
userData = IO RepoCommitFilterResult -> m RepoCommitFilterResult
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RepoCommitFilterResult -> m RepoCommitFilterResult)
-> IO RepoCommitFilterResult -> m RepoCommitFilterResult
forall a b. (a -> b) -> a -> b
$ do
    repo' <- a -> IO (Ptr Repo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    path' <- textToCString path
    fileInfo' <- unsafeManagedPtrCastPtr fileInfo
    result <- (__dynamic_C_RepoCommitFilter __funPtr) repo' path' fileInfo' userData
    let result' = (Int -> RepoCommitFilterResult
forall a. Enum a => Int -> a
toEnum (Int -> RepoCommitFilterResult)
-> (CUInt -> Int) -> CUInt -> RepoCommitFilterResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr repo
    touchManagedPtr fileInfo
    freeMem path'
    return result'

-- | Generate a function pointer callable from C code, from a `C_RepoCommitFilter`.
foreign import ccall "wrapper"
    mk_RepoCommitFilter :: C_RepoCommitFilter -> IO (FunPtr C_RepoCommitFilter)

-- | /No description available in the introspection data./
type RepoCommitFilter =
    OSTree.Repo.Repo
    -- ^ /@repo@/: Repo
    -> T.Text
    -- ^ /@path@/: Path to file
    -> Gio.FileInfo.FileInfo
    -- ^ /@fileInfo@/: File information
    -> IO OSTree.Enums.RepoCommitFilterResult
    -- ^ __Returns:__ t'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitFilter`@.
noRepoCommitFilter :: Maybe RepoCommitFilter
noRepoCommitFilter :: Maybe RepoCommitFilter
noRepoCommitFilter = Maybe RepoCommitFilter
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
type RepoCommitFilter_WithClosures =
    OSTree.Repo.Repo
    -- ^ /@repo@/: Repo
    -> T.Text
    -- ^ /@path@/: Path to file
    -> Gio.FileInfo.FileInfo
    -- ^ /@fileInfo@/: File information
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> IO OSTree.Enums.RepoCommitFilterResult
    -- ^ __Returns:__ t'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitFilter_WithClosures`@.
noRepoCommitFilter_WithClosures :: Maybe RepoCommitFilter_WithClosures
noRepoCommitFilter_WithClosures :: Maybe RepoCommitFilter_WithClosures
noRepoCommitFilter_WithClosures = Maybe RepoCommitFilter_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCommitFilter :: RepoCommitFilter -> RepoCommitFilter_WithClosures
drop_closures_RepoCommitFilter :: RepoCommitFilter -> RepoCommitFilter_WithClosures
drop_closures_RepoCommitFilter RepoCommitFilter
_f Repo
repo Text
path FileInfo
fileInfo Ptr ()
_ = RepoCommitFilter
_f Repo
repo Text
path FileInfo
fileInfo

-- | Wrap the callback into a `GClosure`.
genClosure_RepoCommitFilter :: MonadIO m => RepoCommitFilter -> m (GClosure C_RepoCommitFilter)
genClosure_RepoCommitFilter :: forall (m :: * -> *).
MonadIO m =>
RepoCommitFilter -> m (GClosure C_RepoCommitFilter)
genClosure_RepoCommitFilter RepoCommitFilter
cb = IO (GClosure C_RepoCommitFilter) -> m (GClosure C_RepoCommitFilter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RepoCommitFilter)
 -> m (GClosure C_RepoCommitFilter))
-> IO (GClosure C_RepoCommitFilter)
-> m (GClosure C_RepoCommitFilter)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: RepoCommitFilter_WithClosures
cb' = RepoCommitFilter -> RepoCommitFilter_WithClosures
drop_closures_RepoCommitFilter RepoCommitFilter
cb
    let cb'' :: C_RepoCommitFilter
cb'' = Maybe (Ptr (FunPtr C_RepoCommitFilter))
-> RepoCommitFilter_WithClosures -> C_RepoCommitFilter
wrap_RepoCommitFilter Maybe (Ptr (FunPtr C_RepoCommitFilter))
forall a. Maybe a
Nothing RepoCommitFilter_WithClosures
cb'
    C_RepoCommitFilter -> IO (FunPtr C_RepoCommitFilter)
mk_RepoCommitFilter C_RepoCommitFilter
cb'' IO (FunPtr C_RepoCommitFilter)
-> (FunPtr C_RepoCommitFilter -> IO (GClosure C_RepoCommitFilter))
-> IO (GClosure C_RepoCommitFilter)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RepoCommitFilter -> IO (GClosure C_RepoCommitFilter)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `RepoCommitFilter` into a `C_RepoCommitFilter`.
wrap_RepoCommitFilter :: 
    Maybe (Ptr (FunPtr C_RepoCommitFilter)) ->
    RepoCommitFilter_WithClosures ->
    C_RepoCommitFilter
wrap_RepoCommitFilter :: Maybe (Ptr (FunPtr C_RepoCommitFilter))
-> RepoCommitFilter_WithClosures -> C_RepoCommitFilter
wrap_RepoCommitFilter Maybe (Ptr (FunPtr C_RepoCommitFilter))
gi'funptrptr RepoCommitFilter_WithClosures
gi'cb Ptr Repo
repo CString
path Ptr FileInfo
fileInfo Ptr ()
userData = do
    repo' <- ((ManagedPtr Repo -> Repo) -> Ptr Repo -> IO Repo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
OSTree.Repo.Repo) Ptr Repo
repo
    path' <- cstringToText path
    fileInfo' <- (newObject Gio.FileInfo.FileInfo) fileInfo
    result <- gi'cb  repo' path' fileInfo' userData
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (RepoCommitFilterResult -> Int)
-> RepoCommitFilterResult
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RepoCommitFilterResult -> Int
forall a. Enum a => a -> Int
fromEnum) RepoCommitFilterResult
result
    return result'


-- callback RepoCheckoutFilter
{- Callable
  { returnType =
      Just
        (TInterface
           Name { namespace = "OSTree" , name = "RepoCheckoutFilterResult" })
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation
        { rawDocText =
            Just
              "#OstreeRepoCheckoutFilterResult saying whether or not to checkout this file"
        , sinceVersion = Nothing
        }
  , args =
      [ Arg
          { argCName = "repo"
          , argType =
              TInterface Name { namespace = "OSTree" , name = "Repo" }
          , argCType = Just "OstreeRepo*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation { rawDocText = Just "Repo" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "path"
          , argType = TBasicType TUTF8
          , argCType = Just "const char*"
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "Path to file" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = False
          , transfer = TransferNothing
          }
      , Arg
          { argCName = "stbuf"
          , argType = TBasicType TPtr
          , argCType = Just "stat*"
          , direction = DirectionIn
          , mayBeNull = True
          , argDoc =
              Documentation
                { rawDocText = Just "File information" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , 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 "User data" , sinceVersion = Nothing }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , argCallbackUserData = True
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText = Nothing , sinceVersion = Just "2018.2" }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_RepoCheckoutFilter =
    Ptr OSTree.Repo.Repo ->
    CString ->
    Ptr () ->
    Ptr () ->
    IO CUInt

-- Args: [ Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , argCType = Just "OstreeRepo*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path to file" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stbuf"
--           , argType = TBasicType TPtr
--           , argCType = Just "stat*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "File information" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , 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 "User data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "OSTree" , name = "RepoCheckoutFilterResult" })
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_RepoCheckoutFilter :: FunPtr C_RepoCheckoutFilter -> C_RepoCheckoutFilter

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_RepoCheckoutFilter ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
    FunPtr C_RepoCheckoutFilter
    -> a
    -- ^ /@repo@/: Repo
    -> T.Text
    -- ^ /@path@/: Path to file
    -> Ptr ()
    -- ^ /@stbuf@/: File information
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> m OSTree.Enums.RepoCheckoutFilterResult
    -- ^ __Returns:__ t'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file
dynamic_RepoCheckoutFilter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
FunPtr C_RepoCheckoutFilter
-> a -> Text -> Ptr () -> Ptr () -> m RepoCheckoutFilterResult
dynamic_RepoCheckoutFilter FunPtr C_RepoCheckoutFilter
__funPtr a
repo Text
path Ptr ()
stbuf Ptr ()
userData = IO RepoCheckoutFilterResult -> m RepoCheckoutFilterResult
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RepoCheckoutFilterResult -> m RepoCheckoutFilterResult)
-> IO RepoCheckoutFilterResult -> m RepoCheckoutFilterResult
forall a b. (a -> b) -> a -> b
$ do
    repo' <- a -> IO (Ptr Repo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    path' <- textToCString path
    result <- (__dynamic_C_RepoCheckoutFilter __funPtr) repo' path' stbuf userData
    let result' = (Int -> RepoCheckoutFilterResult
forall a. Enum a => Int -> a
toEnum (Int -> RepoCheckoutFilterResult)
-> (CUInt -> Int) -> CUInt -> RepoCheckoutFilterResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr repo
    freeMem path'
    return result'

-- | Generate a function pointer callable from C code, from a `C_RepoCheckoutFilter`.
foreign import ccall "wrapper"
    mk_RepoCheckoutFilter :: C_RepoCheckoutFilter -> IO (FunPtr C_RepoCheckoutFilter)

-- | /No description available in the introspection data./
-- 
-- /Since: 2018.2/
type RepoCheckoutFilter =
    OSTree.Repo.Repo
    -- ^ /@repo@/: Repo
    -> T.Text
    -- ^ /@path@/: Path to file
    -> Ptr ()
    -- ^ /@stbuf@/: File information
    -> IO OSTree.Enums.RepoCheckoutFilterResult
    -- ^ __Returns:__ t'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCheckoutFilter`@.
noRepoCheckoutFilter :: Maybe RepoCheckoutFilter
noRepoCheckoutFilter :: Maybe RepoCheckoutFilter
noRepoCheckoutFilter = Maybe RepoCheckoutFilter
forall a. Maybe a
Nothing

-- | /No description available in the introspection data./
-- 
-- /Since: 2018.2/
type RepoCheckoutFilter_WithClosures =
    OSTree.Repo.Repo
    -- ^ /@repo@/: Repo
    -> T.Text
    -- ^ /@path@/: Path to file
    -> Ptr ()
    -- ^ /@stbuf@/: File information
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> IO OSTree.Enums.RepoCheckoutFilterResult
    -- ^ __Returns:__ t'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCheckoutFilter_WithClosures`@.
noRepoCheckoutFilter_WithClosures :: Maybe RepoCheckoutFilter_WithClosures
noRepoCheckoutFilter_WithClosures :: Maybe RepoCheckoutFilter_WithClosures
noRepoCheckoutFilter_WithClosures = Maybe RepoCheckoutFilter_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCheckoutFilter :: RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures
drop_closures_RepoCheckoutFilter :: RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures
drop_closures_RepoCheckoutFilter RepoCheckoutFilter
_f Repo
repo Text
path Ptr ()
stbuf Ptr ()
_ = RepoCheckoutFilter
_f Repo
repo Text
path Ptr ()
stbuf

-- | Wrap the callback into a `GClosure`.
genClosure_RepoCheckoutFilter :: MonadIO m => RepoCheckoutFilter -> m (GClosure C_RepoCheckoutFilter)
genClosure_RepoCheckoutFilter :: forall (m :: * -> *).
MonadIO m =>
RepoCheckoutFilter -> m (GClosure C_RepoCheckoutFilter)
genClosure_RepoCheckoutFilter RepoCheckoutFilter
cb = IO (GClosure C_RepoCheckoutFilter)
-> m (GClosure C_RepoCheckoutFilter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RepoCheckoutFilter)
 -> m (GClosure C_RepoCheckoutFilter))
-> IO (GClosure C_RepoCheckoutFilter)
-> m (GClosure C_RepoCheckoutFilter)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: RepoCheckoutFilter_WithClosures
cb' = RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures
drop_closures_RepoCheckoutFilter RepoCheckoutFilter
cb
    let cb'' :: C_RepoCheckoutFilter
cb'' = Maybe (Ptr (FunPtr C_RepoCheckoutFilter))
-> RepoCheckoutFilter_WithClosures -> C_RepoCheckoutFilter
wrap_RepoCheckoutFilter Maybe (Ptr (FunPtr C_RepoCheckoutFilter))
forall a. Maybe a
Nothing RepoCheckoutFilter_WithClosures
cb'
    C_RepoCheckoutFilter -> IO (FunPtr C_RepoCheckoutFilter)
mk_RepoCheckoutFilter C_RepoCheckoutFilter
cb'' IO (FunPtr C_RepoCheckoutFilter)
-> (FunPtr C_RepoCheckoutFilter
    -> IO (GClosure C_RepoCheckoutFilter))
-> IO (GClosure C_RepoCheckoutFilter)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RepoCheckoutFilter -> IO (GClosure C_RepoCheckoutFilter)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `RepoCheckoutFilter` into a `C_RepoCheckoutFilter`.
wrap_RepoCheckoutFilter :: 
    Maybe (Ptr (FunPtr C_RepoCheckoutFilter)) ->
    RepoCheckoutFilter_WithClosures ->
    C_RepoCheckoutFilter
wrap_RepoCheckoutFilter :: Maybe (Ptr (FunPtr C_RepoCheckoutFilter))
-> RepoCheckoutFilter_WithClosures -> C_RepoCheckoutFilter
wrap_RepoCheckoutFilter Maybe (Ptr (FunPtr C_RepoCheckoutFilter))
gi'funptrptr RepoCheckoutFilter_WithClosures
gi'cb Ptr Repo
repo CString
path Ptr ()
stbuf Ptr ()
userData = do
    repo' <- ((ManagedPtr Repo -> Repo) -> Ptr Repo -> IO Repo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
OSTree.Repo.Repo) Ptr Repo
repo
    path' <- cstringToText path
    result <- gi'cb  repo' path' stbuf userData
    maybeReleaseFunPtr gi'funptrptr
    let result' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (RepoCheckoutFilterResult -> Int)
-> RepoCheckoutFilterResult
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RepoCheckoutFilterResult -> Int
forall a. Enum a => a -> Int
fromEnum) RepoCheckoutFilterResult
result
    return result'