{-# 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.Dazzle.Structs.CounterArena
    ( 

-- * Exported types
    CounterArena(..)                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [foreach]("GI.Dazzle.Structs.CounterArena#g:method:foreach"), [ref]("GI.Dazzle.Structs.CounterArena#g:method:ref"), [register]("GI.Dazzle.Structs.CounterArena#g:method:register"), [unref]("GI.Dazzle.Structs.CounterArena#g:method:unref").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveCounterArenaMethod               ,
#endif

-- ** foreach #method:foreach#

#if defined(ENABLE_OVERLOADING)
    CounterArenaForeachMethodInfo           ,
#endif
    counterArenaForeach                     ,


-- ** getDefault #method:getDefault#

    counterArenaGetDefault                  ,


-- ** newForPid #method:newForPid#

    counterArenaNewForPid                   ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    CounterArenaRefMethodInfo               ,
#endif
    counterArenaRef                         ,


-- ** register #method:register#

#if defined(ENABLE_OVERLOADING)
    CounterArenaRegisterMethodInfo          ,
#endif
    counterArenaRegister                    ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    CounterArenaUnrefMethodInfo             ,
#endif
    counterArenaUnref                       ,




    ) 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.Dazzle.Callbacks as Dazzle.Callbacks
import {-# SOURCE #-} qualified GI.Dazzle.Structs.Counter as Dazzle.Counter
import {-# SOURCE #-} qualified GI.Dazzle.Structs.CounterValue as Dazzle.CounterValue

#else
import qualified GI.Dazzle.Callbacks as Dazzle.Callbacks
import {-# SOURCE #-} qualified GI.Dazzle.Structs.Counter as Dazzle.Counter

#endif

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

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

foreign import ccall "dzl_counter_arena_get_type" c_dzl_counter_arena_get_type :: 
    IO GType

type instance O.ParentTypes CounterArena = '[]
instance O.HasParentTypes CounterArena

instance B.Types.TypedObject CounterArena where
    glibType :: IO GType
glibType = IO GType
c_dzl_counter_arena_get_type

instance B.Types.GBoxed CounterArena

-- | Convert 'CounterArena' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe CounterArena) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_dzl_counter_arena_get_type
    gvalueSet_ :: Ptr GValue -> Maybe CounterArena -> IO ()
gvalueSet_ Ptr GValue
gv Maybe CounterArena
P.Nothing = Ptr GValue -> Ptr CounterArena -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr CounterArena
forall a. Ptr a
FP.nullPtr :: FP.Ptr CounterArena)
    gvalueSet_ Ptr GValue
gv (P.Just CounterArena
obj) = CounterArena -> (Ptr CounterArena -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CounterArena
obj (Ptr GValue -> Ptr CounterArena -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe CounterArena)
gvalueGet_ Ptr GValue
gv = do
        Ptr CounterArena
ptr <- Ptr GValue -> IO (Ptr CounterArena)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr CounterArena)
        if Ptr CounterArena
ptr Ptr CounterArena -> Ptr CounterArena -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr CounterArena
forall a. Ptr a
FP.nullPtr
        then CounterArena -> Maybe CounterArena
forall a. a -> Maybe a
P.Just (CounterArena -> Maybe CounterArena)
-> IO CounterArena -> IO (Maybe CounterArena)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr CounterArena -> CounterArena)
-> Ptr CounterArena -> IO CounterArena
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr CounterArena -> CounterArena
CounterArena Ptr CounterArena
ptr
        else Maybe CounterArena -> IO (Maybe CounterArena)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CounterArena
forall a. Maybe a
P.Nothing
        
    


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

-- method CounterArena::new_for_pid
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "pid"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Dazzle" , name = "CounterArena" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_counter_arena_new_for_pid" dzl_counter_arena_new_for_pid :: 
    Int32 ->                                -- pid : TBasicType TInt
    IO (Ptr CounterArena)

-- | /No description available in the introspection data./
counterArenaNewForPid ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Int32
    -> m CounterArena
counterArenaNewForPid :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Int32 -> m CounterArena
counterArenaNewForPid Int32
pid = IO CounterArena -> m CounterArena
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CounterArena -> m CounterArena)
-> IO CounterArena -> m CounterArena
forall a b. (a -> b) -> a -> b
$ do
    Ptr CounterArena
result <- Int32 -> IO (Ptr CounterArena)
dzl_counter_arena_new_for_pid Int32
pid
    Text -> Ptr CounterArena -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"counterArenaNewForPid" Ptr CounterArena
result
    CounterArena
result' <- ((ManagedPtr CounterArena -> CounterArena)
-> Ptr CounterArena -> IO CounterArena
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CounterArena -> CounterArena
CounterArena) Ptr CounterArena
result
    CounterArena -> IO CounterArena
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CounterArena
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method CounterArena::foreach
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "arena"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "CounterArena" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #DzlCounterArena"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "CounterForeachFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A callback to execute"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @func"
--                 , 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 "dzl_counter_arena_foreach" dzl_counter_arena_foreach :: 
    Ptr CounterArena ->                     -- arena : TInterface (Name {namespace = "Dazzle", name = "CounterArena"})
    FunPtr Dazzle.Callbacks.C_CounterForeachFunc -> -- func : TInterface (Name {namespace = "Dazzle", name = "CounterForeachFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Calls /@func@/ for every counter found in /@area@/.
counterArenaForeach ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CounterArena
    -- ^ /@arena@/: An t'GI.Dazzle.Structs.CounterArena.CounterArena'
    -> Dazzle.Callbacks.CounterForeachFunc
    -- ^ /@func@/: A callback to execute
    -> m ()
counterArenaForeach :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CounterArena -> CounterForeachFunc -> m ()
counterArenaForeach CounterArena
arena CounterForeachFunc
func = 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
    Ptr CounterArena
arena' <- CounterArena -> IO (Ptr CounterArena)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CounterArena
arena
    FunPtr C_CounterForeachFunc
func' <- C_CounterForeachFunc -> IO (FunPtr C_CounterForeachFunc)
Dazzle.Callbacks.mk_CounterForeachFunc (Maybe (Ptr (FunPtr C_CounterForeachFunc))
-> CounterForeachFunc_WithClosures -> C_CounterForeachFunc
Dazzle.Callbacks.wrap_CounterForeachFunc Maybe (Ptr (FunPtr C_CounterForeachFunc))
forall a. Maybe a
Nothing (CounterForeachFunc -> CounterForeachFunc_WithClosures
Dazzle.Callbacks.drop_closures_CounterForeachFunc CounterForeachFunc
func))
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr CounterArena -> FunPtr C_CounterForeachFunc -> Ptr () -> IO ()
dzl_counter_arena_foreach Ptr CounterArena
arena' FunPtr C_CounterForeachFunc
func' Ptr ()
forall a. Ptr a
userData
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_CounterForeachFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CounterForeachFunc
func'
    CounterArena -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CounterArena
arena
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CounterArenaForeachMethodInfo
instance (signature ~ (Dazzle.Callbacks.CounterForeachFunc -> m ()), MonadIO m) => O.OverloadedMethod CounterArenaForeachMethodInfo CounterArena signature where
    overloadedMethod = counterArenaForeach

instance O.OverloadedMethodInfo CounterArenaForeachMethodInfo CounterArena where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.CounterArena.counterArenaForeach",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-CounterArena.html#v:counterArenaForeach"
        })


#endif

-- method CounterArena::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "arena"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "CounterArena" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Dazzle" , name = "CounterArena" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_counter_arena_ref" dzl_counter_arena_ref :: 
    Ptr CounterArena ->                     -- arena : TInterface (Name {namespace = "Dazzle", name = "CounterArena"})
    IO (Ptr CounterArena)

-- | /No description available in the introspection data./
counterArenaRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CounterArena
    -> m CounterArena
counterArenaRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CounterArena -> m CounterArena
counterArenaRef CounterArena
arena = IO CounterArena -> m CounterArena
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CounterArena -> m CounterArena)
-> IO CounterArena -> m CounterArena
forall a b. (a -> b) -> a -> b
$ do
    Ptr CounterArena
arena' <- CounterArena -> IO (Ptr CounterArena)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CounterArena
arena
    Ptr CounterArena
result <- Ptr CounterArena -> IO (Ptr CounterArena)
dzl_counter_arena_ref Ptr CounterArena
arena'
    Text -> Ptr CounterArena -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"counterArenaRef" Ptr CounterArena
result
    CounterArena
result' <- ((ManagedPtr CounterArena -> CounterArena)
-> Ptr CounterArena -> IO CounterArena
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CounterArena -> CounterArena
CounterArena) Ptr CounterArena
result
    CounterArena -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CounterArena
arena
    CounterArena -> IO CounterArena
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CounterArena
result'

#if defined(ENABLE_OVERLOADING)
data CounterArenaRefMethodInfo
instance (signature ~ (m CounterArena), MonadIO m) => O.OverloadedMethod CounterArenaRefMethodInfo CounterArena signature where
    overloadedMethod = counterArenaRef

instance O.OverloadedMethodInfo CounterArenaRefMethodInfo CounterArena where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.CounterArena.counterArenaRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-CounterArena.html#v:counterArenaRef"
        })


#endif

-- method CounterArena::register
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "arena"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "CounterArena" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "counter"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "Counter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 "dzl_counter_arena_register" dzl_counter_arena_register :: 
    Ptr CounterArena ->                     -- arena : TInterface (Name {namespace = "Dazzle", name = "CounterArena"})
    Ptr Dazzle.Counter.Counter ->           -- counter : TInterface (Name {namespace = "Dazzle", name = "Counter"})
    IO ()

-- | /No description available in the introspection data./
counterArenaRegister ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CounterArena
    -> Dazzle.Counter.Counter
    -> m ()
counterArenaRegister :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CounterArena -> Counter -> m ()
counterArenaRegister CounterArena
arena Counter
counter = 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
    Ptr CounterArena
arena' <- CounterArena -> IO (Ptr CounterArena)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CounterArena
arena
    Ptr Counter
counter' <- Counter -> IO (Ptr Counter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Counter
counter
    Ptr CounterArena -> Ptr Counter -> IO ()
dzl_counter_arena_register Ptr CounterArena
arena' Ptr Counter
counter'
    CounterArena -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CounterArena
arena
    CounterForeachFunc
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Counter
counter
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CounterArenaRegisterMethodInfo
instance (signature ~ (Dazzle.Counter.Counter -> m ()), MonadIO m) => O.OverloadedMethod CounterArenaRegisterMethodInfo CounterArena signature where
    overloadedMethod = counterArenaRegister

instance O.OverloadedMethodInfo CounterArenaRegisterMethodInfo CounterArena where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.CounterArena.counterArenaRegister",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-CounterArena.html#v:counterArenaRegister"
        })


#endif

-- method CounterArena::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "arena"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "CounterArena" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 "dzl_counter_arena_unref" dzl_counter_arena_unref :: 
    Ptr CounterArena ->                     -- arena : TInterface (Name {namespace = "Dazzle", name = "CounterArena"})
    IO ()

-- | /No description available in the introspection data./
counterArenaUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CounterArena
    -> m ()
counterArenaUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CounterArena -> m ()
counterArenaUnref CounterArena
arena = 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
    Ptr CounterArena
arena' <- CounterArena -> IO (Ptr CounterArena)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CounterArena
arena
    Ptr CounterArena -> IO ()
dzl_counter_arena_unref Ptr CounterArena
arena'
    CounterArena -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CounterArena
arena
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CounterArenaUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod CounterArenaUnrefMethodInfo CounterArena signature where
    overloadedMethod = counterArenaUnref

instance O.OverloadedMethodInfo CounterArenaUnrefMethodInfo CounterArena where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.CounterArena.counterArenaUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-CounterArena.html#v:counterArenaUnref"
        })


#endif

-- method CounterArena::get_default
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Dazzle" , name = "CounterArena" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_counter_arena_get_default" dzl_counter_arena_get_default :: 
    IO (Ptr CounterArena)

-- | /No description available in the introspection data./
counterArenaGetDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m CounterArena
counterArenaGetDefault :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m CounterArena
counterArenaGetDefault  = IO CounterArena -> m CounterArena
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CounterArena -> m CounterArena)
-> IO CounterArena -> m CounterArena
forall a b. (a -> b) -> a -> b
$ do
    Ptr CounterArena
result <- IO (Ptr CounterArena)
dzl_counter_arena_get_default
    Text -> Ptr CounterArena -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"counterArenaGetDefault" Ptr CounterArena
result
    CounterArena
result' <- ((ManagedPtr CounterArena -> CounterArena)
-> Ptr CounterArena -> IO CounterArena
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CounterArena -> CounterArena
CounterArena) Ptr CounterArena
result
    CounterArena -> IO CounterArena
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CounterArena
result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveCounterArenaMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveCounterArenaMethod "foreach" o = CounterArenaForeachMethodInfo
    ResolveCounterArenaMethod "ref" o = CounterArenaRefMethodInfo
    ResolveCounterArenaMethod "register" o = CounterArenaRegisterMethodInfo
    ResolveCounterArenaMethod "unref" o = CounterArenaUnrefMethodInfo
    ResolveCounterArenaMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif