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

    Represents a scope for loading IO modules. A scope can be used for blocking
    duplicate modules, or blocking a module you don\'t want to load.

    The scope can be used with @/g_io_modules_load_all_in_directory_with_scope()/@
    or 'GI.Gio.Functions.ioModulesScanAllInDirectoryWithScope'.

    /Since: 2.30/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Structs.IOModuleScope
        (

    -- * Exported types
        IOModuleScope(..)                       ,
        noIOModuleScope                         ,

     -- * Methods
    -- ** block #method:block#

    #if ENABLE_OVERLOADING
        IOModuleScopeBlockMethodInfo            ,
    #endif
        iOModuleScopeBlock                      ,

    -- ** free #method:free#

    #if ENABLE_OVERLOADING
        IOModuleScopeFreeMethodInfo             ,
    #endif
        iOModuleScopeFree                       ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    -- | Memory-managed wrapper type.
    newtype IOModuleScope = IOModuleScope (ManagedPtr IOModuleScope)
    -- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
    instance WrappedPtr IOModuleScope where
        wrappedPtrCalloc = return nullPtr
        wrappedPtrCopy = return
        wrappedPtrFree = Nothing

    -- | A convenience alias for `Nothing` :: `Maybe` `IOModuleScope`.
    noIOModuleScope :: Maybe IOModuleScope
    noIOModuleScope = Nothing

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList IOModuleScope
    type instance O.AttributeList IOModuleScope = IOModuleScopeAttributeList
    type IOModuleScopeAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    -- method IOModuleScope::block
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scope", argType = TInterface (Name {namespace = "Gio", name = "IOModuleScope"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a module loading scope", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "basename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the basename to block", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_module_scope_block" g_io_module_scope_block ::
        Ptr IOModuleScope ->                    -- scope : TInterface (Name {namespace = "Gio", name = "IOModuleScope"})
        CString ->                              -- basename : TBasicType TUTF8
        IO ()

    {- |
    Block modules with the given /@basename@/ from being loaded when
    this scope is used with 'GI.Gio.Functions.ioModulesScanAllInDirectoryWithScope'
    or @/g_io_modules_load_all_in_directory_with_scope()/@.

    /Since: 2.30/
    -}
    iOModuleScopeBlock ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOModuleScope
        {- ^ /@scope@/: a module loading scope -}
        -> T.Text
        {- ^ /@basename@/: the basename to block -}
        -> m ()
    iOModuleScopeBlock scope basename = liftIO $ do
        scope' <- unsafeManagedPtrGetPtr scope
        basename' <- textToCString basename
        g_io_module_scope_block scope' basename'
        touchManagedPtr scope
        freeMem basename'
        return ()

    #if ENABLE_OVERLOADING
    data IOModuleScopeBlockMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo IOModuleScopeBlockMethodInfo IOModuleScope signature where
        overloadedMethod _ = iOModuleScopeBlock

    #endif

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

    foreign import ccall "g_io_module_scope_free" g_io_module_scope_free ::
        Ptr IOModuleScope ->                    -- scope : TInterface (Name {namespace = "Gio", name = "IOModuleScope"})
        IO ()

    {- |
    Free a module scope.

    /Since: 2.30/
    -}
    iOModuleScopeFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOModuleScope
        {- ^ /@scope@/: a module loading scope -}
        -> m ()
    iOModuleScopeFree scope = liftIO $ do
        scope' <- unsafeManagedPtrGetPtr scope
        g_io_module_scope_free scope'
        touchManagedPtr scope
        return ()

    #if ENABLE_OVERLOADING
    data IOModuleScopeFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IOModuleScopeFreeMethodInfo IOModuleScope signature where
        overloadedMethod _ = iOModuleScopeFree

    #endif

    #if ENABLE_OVERLOADING
    type family ResolveIOModuleScopeMethod (t :: Symbol) (o :: *) :: * where
        ResolveIOModuleScopeMethod "block" o = IOModuleScopeBlockMethodInfo
        ResolveIOModuleScopeMethod "free" o = IOModuleScopeFreeMethodInfo
        ResolveIOModuleScopeMethod l o = O.MethodResolutionFailed l o

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

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

    #endif