{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.GObject.Structs.ParamSpecPool.ParamSpecPool' maintains a collection of @/GParamSpecs/@ which can be
-- quickly accessed by owner and name.
-- 
-- The implementation of the t'GI.GObject.Objects.Object.Object' property system uses such a pool to
-- store the @/GParamSpecs/@ of the properties all object types.

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

module GI.GObject.Structs.ParamSpecPool
    ( 

-- * Exported types
    ParamSpecPool(..)                       ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [insert]("GI.GObject.Structs.ParamSpecPool#g:method:insert"), [listOwned]("GI.GObject.Structs.ParamSpecPool#g:method:listOwned"), [lookup]("GI.GObject.Structs.ParamSpecPool#g:method:lookup"), [remove]("GI.GObject.Structs.ParamSpecPool#g:method:remove").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveParamSpecPoolMethod              ,
#endif

-- ** insert #method:insert#

#if defined(ENABLE_OVERLOADING)
    ParamSpecPoolInsertMethodInfo           ,
#endif
    paramSpecPoolInsert                     ,


-- ** listOwned #method:listOwned#

#if defined(ENABLE_OVERLOADING)
    ParamSpecPoolListOwnedMethodInfo        ,
#endif
    paramSpecPoolListOwned                  ,


-- ** lookup #method:lookup#

#if defined(ENABLE_OVERLOADING)
    ParamSpecPoolLookupMethodInfo           ,
#endif
    paramSpecPoolLookup                     ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    ParamSpecPoolRemoveMethodInfo           ,
#endif
    paramSpecPoolRemove                     ,




    ) 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)

#else

#endif

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

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

-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance BoxedPtr ParamSpecPool where
    boxedPtrCopy :: ParamSpecPool -> IO ParamSpecPool
boxedPtrCopy = ParamSpecPool -> IO ParamSpecPool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
    boxedPtrFree :: ParamSpecPool -> IO ()
boxedPtrFree = \ParamSpecPool
_x -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


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

-- XXX Could not generate method ParamSpecPool::free
-- Bad introspection data: Transferring a non-boxed struct with unknown size!
-- method ParamSpecPool::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ParamSpecPool" }
--           , argCType = Just "GParamSpecPool*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GParamSpecPool." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , argCType = Just "GParamSpec*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GParamSpec to insert"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "owner_type"
--           , argType = TBasicType TGType
--           , argCType = Just "GType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GType identifying the owner of @pspec"
--                 , 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 "g_param_spec_pool_insert" g_param_spec_pool_insert :: 
    Ptr ParamSpecPool ->                    -- pool : TInterface (Name {namespace = "GObject", name = "ParamSpecPool"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    CGType ->                               -- owner_type : TBasicType TGType
    IO ()

-- | Inserts a t'GI.GObject.Objects.ParamSpec.ParamSpec' in the pool.
paramSpecPoolInsert ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ParamSpecPool
    -- ^ /@pool@/: a t'GI.GObject.Structs.ParamSpecPool.ParamSpecPool'.
    -> GParamSpec
    -- ^ /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' to insert
    -> GType
    -- ^ /@ownerType@/: a t'GType' identifying the owner of /@pspec@/
    -> m ()
paramSpecPoolInsert :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ParamSpecPool -> GParamSpec -> GType -> m ()
paramSpecPoolInsert ParamSpecPool
pool GParamSpec
pspec GType
ownerType = 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
    pool' <- ParamSpecPool -> IO (Ptr ParamSpecPool)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ParamSpecPool
pool
    pspec' <- unsafeManagedPtrGetPtr pspec
    let ownerType' = GType -> CGType
gtypeToCGType GType
ownerType
    g_param_spec_pool_insert pool' pspec' ownerType'
    touchManagedPtr pool
    touchManagedPtr pspec
    return ()

#if defined(ENABLE_OVERLOADING)
data ParamSpecPoolInsertMethodInfo
instance (signature ~ (GParamSpec -> GType -> m ()), MonadIO m) => O.OverloadedMethod ParamSpecPoolInsertMethodInfo ParamSpecPool signature where
    overloadedMethod = paramSpecPoolInsert

instance O.OverloadedMethodInfo ParamSpecPoolInsertMethodInfo ParamSpecPool where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.ParamSpecPool.paramSpecPoolInsert",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-ParamSpecPool.html#v:paramSpecPoolInsert"
        })


#endif

-- XXX Could not generate method ParamSpecPool::list
-- Not implemented: unpackCArray : Don't know how to unpack C Array of type TParamSpec
-- method ParamSpecPool::list_owned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ParamSpecPool" }
--           , argCType = Just "GParamSpecPool*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GParamSpecPool" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "owner_type"
--           , argType = TBasicType TGType
--           , argCType = Just "GType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the owner to look for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TGList TParamSpec)
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_pool_list_owned" g_param_spec_pool_list_owned :: 
    Ptr ParamSpecPool ->                    -- pool : TInterface (Name {namespace = "GObject", name = "ParamSpecPool"})
    CGType ->                               -- owner_type : TBasicType TGType
    IO (Ptr (GList (Ptr GParamSpec)))

-- | Gets an t'GI.GLib.Structs.List.List' of all @/GParamSpecs/@ owned by /@ownerType@/ in
-- the pool.
paramSpecPoolListOwned ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ParamSpecPool
    -- ^ /@pool@/: a t'GI.GObject.Structs.ParamSpecPool.ParamSpecPool'
    -> GType
    -- ^ /@ownerType@/: the owner to look for
    -> m [GParamSpec]
    -- ^ __Returns:__ a
    --          t'GI.GLib.Structs.List.List' of all @/GParamSpecs/@ owned by /@ownerType@/ in
    --          the pool@/GParamSpecs/@.
paramSpecPoolListOwned :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ParamSpecPool -> GType -> m [GParamSpec]
paramSpecPoolListOwned ParamSpecPool
pool GType
ownerType = IO [GParamSpec] -> m [GParamSpec]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [GParamSpec] -> m [GParamSpec])
-> IO [GParamSpec] -> m [GParamSpec]
forall a b. (a -> b) -> a -> b
$ do
    pool' <- ParamSpecPool -> IO (Ptr ParamSpecPool)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ParamSpecPool
pool
    let ownerType' = GType -> CGType
gtypeToCGType GType
ownerType
    result <- g_param_spec_pool_list_owned pool' ownerType'
    result' <- unpackGList result
    result'' <- mapM B.GParamSpec.newGParamSpecFromPtr result'
    g_list_free result
    touchManagedPtr pool
    return result''

#if defined(ENABLE_OVERLOADING)
data ParamSpecPoolListOwnedMethodInfo
instance (signature ~ (GType -> m [GParamSpec]), MonadIO m) => O.OverloadedMethod ParamSpecPoolListOwnedMethodInfo ParamSpecPool signature where
    overloadedMethod = paramSpecPoolListOwned

instance O.OverloadedMethodInfo ParamSpecPoolListOwnedMethodInfo ParamSpecPool where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.ParamSpecPool.paramSpecPoolListOwned",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-ParamSpecPool.html#v:paramSpecPoolListOwned"
        })


#endif

-- method ParamSpecPool::lookup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pool"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ParamSpecPool" }
--           , argCType = Just "GParamSpecPool*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GParamSpecPool" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "param_name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name to look for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "owner_type"
--           , argType = TBasicType TGType
--           , argCType = Just "GType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the owner to look for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "walk_ancestors"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "If %TRUE, also try to find a #GParamSpec with @param_name\n owned by an ancestor of @owner_type."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TParamSpec
-- throws : False
-- Skip return : False

foreign import ccall "g_param_spec_pool_lookup" g_param_spec_pool_lookup :: 
    Ptr ParamSpecPool ->                    -- pool : TInterface (Name {namespace = "GObject", name = "ParamSpecPool"})
    CString ->                              -- param_name : TBasicType TUTF8
    CGType ->                               -- owner_type : TBasicType TGType
    CInt ->                                 -- walk_ancestors : TBasicType TBoolean
    IO (Ptr GParamSpec)

-- | Looks up a t'GI.GObject.Objects.ParamSpec.ParamSpec' in the pool.
paramSpecPoolLookup ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ParamSpecPool
    -- ^ /@pool@/: a t'GI.GObject.Structs.ParamSpecPool.ParamSpecPool'
    -> T.Text
    -- ^ /@paramName@/: the name to look for
    -> GType
    -- ^ /@ownerType@/: the owner to look for
    -> Bool
    -- ^ /@walkAncestors@/: If 'P.True', also try to find a t'GI.GObject.Objects.ParamSpec.ParamSpec' with /@paramName@/
    --  owned by an ancestor of /@ownerType@/.
    -> m (Maybe GParamSpec)
    -- ^ __Returns:__ The found t'GI.GObject.Objects.ParamSpec.ParamSpec', or 'P.Nothing' if no
    -- matching t'GI.GObject.Objects.ParamSpec.ParamSpec' was found.
paramSpecPoolLookup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ParamSpecPool -> Text -> GType -> Bool -> m (Maybe GParamSpec)
paramSpecPoolLookup ParamSpecPool
pool Text
paramName GType
ownerType Bool
walkAncestors = IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GParamSpec) -> m (Maybe GParamSpec))
-> IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ do
    pool' <- ParamSpecPool -> IO (Ptr ParamSpecPool)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ParamSpecPool
pool
    paramName' <- textToCString paramName
    let ownerType' = GType -> CGType
gtypeToCGType GType
ownerType
    let walkAncestors' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
walkAncestors
    result <- g_param_spec_pool_lookup pool' paramName' ownerType' walkAncestors'
    maybeResult <- convertIfNonNull result $ \Ptr GParamSpec
result' -> do
        result'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result'
        return result''
    touchManagedPtr pool
    freeMem paramName'
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data ParamSpecPoolLookupMethodInfo
instance (signature ~ (T.Text -> GType -> Bool -> m (Maybe GParamSpec)), MonadIO m) => O.OverloadedMethod ParamSpecPoolLookupMethodInfo ParamSpecPool signature where
    overloadedMethod = paramSpecPoolLookup

instance O.OverloadedMethodInfo ParamSpecPoolLookupMethodInfo ParamSpecPool where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Structs.ParamSpecPool.paramSpecPoolLookupss="hs-identifier hs-var">s ((Ptr ObjectConstructParam -> IO ()) -> IO ())
-> (Ptr ObjectConstructParam -> IO (!23"file:///usr/lib/ghc/lib/../../../share/doc/ghc-doc/html/libraries/ghc-internal-9.1003.0-inplace/src/GHC.Internal.Data.Traversable.html#mapM">mapMO.resolvedSymbolName = "GI.GObject.Stopan id="line-330">--           , argCType = Just "GParamSpecPool*"
--           , direction = DirectionIn
mapMO.resolvedSymbolName maybeResult <-
Maybe GParamSpec)--           , argCType = Just "GParamSpecPool*"
--           , argCType = Just "const m -> IO ()) -> IO ())
-> (Ptr ObjectConstructParam -> IO (!23"file:///usr/lib/ghc/lib/../../../share/doc/ghc-doc/html/libraries/ghc-internal-9.1003.0-inplace/src/GHC.Internal.Datasignature where

--           ,line-332">                               ,
GParamSpec)--           , argCType = Just "GParamSpecPool*"
--           , argCType = JBool
as --           , argCallerAllocates = False
--           , argCallbackUserData = False

v
    dbgAttrInf/span>



-- 
 -> m (Maybe GParamSpec)result''
MonadIO m--               TInterface Name { namespace = "GObje "GParamSpecPool*"
(Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -span> --           , argCType = Just "GParamSpecPool*"
--           , argScope = Sc"file:///usr/lib/ghc/lib/../../../share/doc/ghc-doc/html/libraries/text-2.1.3-inplace/src/Data.Text.InteG/span> (span>-- take a t'GI.GObject.Objects.Object.ObjectamSpec)
forall a. IO a -> m a
forall (m =
--                     Just
result''
MonadIO --         891<
Bcpo    
--           { ar="hs-identifier">SignalGrouGNindSignalInfo --           , argType = TBasicType TGType
--           , argCType = Just "GTlueTable.TypeValueTable -> = ('[    
, ObjectConstructParamPspecFieldInfo), '(where
), ObjectConstructParamPspecFieldInfop          , sinceVersion = Nothing
--          t">"g_param_spec_pool_insert" m
--           { ar="hs-identifier">SignalGrouGNindSignalInfo --           , argType = TBasicTypo                              -- walk_ancestors : TBasicType", argGn>"g_param_spec_pool_insert" import g_param_spec_pool_insertdPtrNewtype a) => a -> IO (Ptr a)
ptrPtr ClosureNotifyData -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
 

#if !defined>        CString     Ptr -- owner_type : TBasicType TGType
import --          t">"g_param_san>import Ptr <(~)(paramSpecUint64 --           , argCType = Just "const m -> IO ()) -> IO 4">)(paramSpecPoolLookup
 as GValue)-- Skip return : False

import --           , argCType = Just "const m -> IO ()) -> IO 4">--          t">return --                    8">
-- Args: [onst m -> IO ()) -> IO 4">--    n> --                     Just--           , argCType = Just &quan id="line-326">-- Args: [onst m -> IO (pan class="hs-idern 
--          (

#endif

instance (info ~ --           
=>
    => R.HasField --    n> m lass="hs-keyword">qualified GParamSpecDataerty to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is aramSpecPool
)
cleUshare/doc/ghc-doc/html/libraries/ghc-internal-9.1003.0-inplace/src/GHC.Internal.Maybe.html#Maybe">Maybe =m) SignalGroup) Text
jBlurb -> an> attrClear )-- Args: [onst m -> IO (pan class="hs-idernGParamSpec
SignalGroup) Prelude as)
--          621679209172">jBlurbinstance (infoMaybe =m<(a>) ObjectConstructParamPspecFieldInfop          , sinceVersion = Nothing
--  span>
--      n> v
    Prelude as)infopool' Maybe =m<(a>) --          t">retur class="annot">--                    8">
Bool -> Int
forall a. Enum a => a n>-- Args: [onst m -> IO ()) -> IO 4">Bool
walkAncestors
    jBlurbinstance                                ,
GParamSpec)--           , argCType = Just "GParamSpecPool*"Maybe m )-- c/GHC.Internal.Maybe.html#Maybe">Maybe26989586621679209160">ownerType ObjectConstructParamPspecFieldInfop          , sinceVersiolef="#local-6989586621679209172">v
    Bool
walkAncestors
    --           , argCType = Just "GParamSpecPool*"
= paramNameparamName'2t">
--      n>Text
m<">ownerType Bool
walkAncestors = IO Spec
<- => OL.IsLabel t 
)
    Maybe =m) SignalGroup) result <- maybeResultg_param_sppan> 
)
  <- import 1sult <--6989586621679209158">poolSignalGroup )
<{span> SignalGroup)   =mas Bool
walkAncestors
    P.fromIntegral 

)  walkAncestors
Bool -> Int
forall a. Enum a => a -> Int
as Bool
walkAncestors
) Maybe  GObject.ParamSpec.ParamSpecSinkMethodInfo
    

--           , argDoc =
--               Documentation