{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.DebugCategory
(
DebugCategory(..) ,
newZeroDebugCategory ,
#if defined(ENABLE_OVERLOADING)
ResolveDebugCategoryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DebugCategoryFreeMethodInfo ,
#endif
debugCategoryFree ,
#if defined(ENABLE_OVERLOADING)
DebugCategoryGetColorMethodInfo ,
#endif
debugCategoryGetColor ,
#if defined(ENABLE_OVERLOADING)
DebugCategoryGetDescriptionMethodInfo ,
#endif
debugCategoryGetDescription ,
#if defined(ENABLE_OVERLOADING)
DebugCategoryGetNameMethodInfo ,
#endif
debugCategoryGetName ,
#if defined(ENABLE_OVERLOADING)
DebugCategoryGetThresholdMethodInfo ,
#endif
debugCategoryGetThreshold ,
#if defined(ENABLE_OVERLOADING)
DebugCategoryResetThresholdMethodInfo ,
#endif
debugCategoryResetThreshold ,
#if defined(ENABLE_OVERLOADING)
DebugCategorySetThresholdMethodInfo ,
#endif
debugCategorySetThreshold ,
) 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.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 {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
newtype DebugCategory = DebugCategory (SP.ManagedPtr DebugCategory)
deriving (DebugCategory -> DebugCategory -> Bool
(DebugCategory -> DebugCategory -> Bool)
-> (DebugCategory -> DebugCategory -> Bool) -> Eq DebugCategory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DebugCategory -> DebugCategory -> Bool
== :: DebugCategory -> DebugCategory -> Bool
$c/= :: DebugCategory -> DebugCategory -> Bool
/= :: DebugCategory -> DebugCategory -> Bool
Eq)
instance SP.ManagedPtrNewtype DebugCategory where
toManagedPtr :: DebugCategory -> ManagedPtr DebugCategory
toManagedPtr (DebugCategory ManagedPtr DebugCategory
p) = ManagedPtr DebugCategory
p
instance BoxedPtr DebugCategory where
boxedPtrCopy :: DebugCategory -> IO DebugCategory
boxedPtrCopy = \DebugCategory
p -> DebugCategory
-> (Ptr DebugCategory -> IO DebugCategory) -> IO DebugCategory
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DebugCategory
p (Int -> Ptr DebugCategory -> IO (Ptr DebugCategory)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 (Ptr DebugCategory -> IO (Ptr DebugCategory))
-> (Ptr DebugCategory -> IO DebugCategory)
-> Ptr DebugCategory
-> IO DebugCategory
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr DebugCategory -> DebugCategory)
-> Ptr DebugCategory -> IO DebugCategory
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr DebugCategory -> DebugCategory
DebugCategory)
boxedPtrFree :: DebugCategory -> IO ()
boxedPtrFree = \DebugCategory
x -> DebugCategory -> (Ptr DebugCategory -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr DebugCategory
x Ptr DebugCategory -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr DebugCategory where
boxedPtrCalloc :: IO (Ptr DebugCategory)
boxedPtrCalloc = Int -> IO (Ptr DebugCategory)
forall a. Int -> IO (Ptr a)
callocBytes Int
24
newZeroDebugCategory :: MonadIO m => m DebugCategory
newZeroDebugCategory :: forall (m :: * -> *). MonadIO m => m DebugCategory
newZeroDebugCategory = IO DebugCategory -> m DebugCategory
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DebugCategory -> m DebugCategory)
-> IO DebugCategory -> m DebugCategory
forall a b. (a -> b) -> a -> b
$ IO (Ptr DebugCategory)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr DebugCategory)
-> (Ptr DebugCategory -> IO DebugCategory) -> IO DebugCategory
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr DebugCategory -> DebugCategory)
-> Ptr DebugCategory -> IO DebugCategory
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr DebugCategory -> DebugCategory
DebugCategory
instance tag ~ 'AttrSet => Constructible DebugCategory tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr DebugCategory -> DebugCategory)
-> [AttrOp DebugCategory tag] -> m DebugCategory
new ManagedPtr DebugCategory -> DebugCategory
_ [AttrOp DebugCategory tag]
attrs = do
DebugCategory
o <- m DebugCategory
forall (m :: * -> *). MonadIO m => m DebugCategory
newZeroDebugCategory
DebugCategory -> [AttrOp DebugCategory 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set DebugCategory
o [AttrOp DebugCategory tag]
[AttrOp DebugCategory 'AttrSet]
attrs
DebugCategory -> m DebugCategory
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return DebugCategory
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DebugCategory
type instance O.AttributeList DebugCategory = DebugCategoryAttributeList
type DebugCategoryAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "gst_debug_category_free" gst_debug_category_free ::
Ptr DebugCategory ->
IO ()
{-# DEPRECATED debugCategoryFree ["This function can easily cause memory corruption, don\\'t use it."] #-}
debugCategoryFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
DebugCategory
-> m ()
debugCategoryFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DebugCategory -> m ()
debugCategoryFree DebugCategory
category = 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 DebugCategory
category' <- DebugCategory -> IO (Ptr DebugCategory)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DebugCategory
category
Ptr DebugCategory -> IO ()
gst_debug_category_free Ptr DebugCategory
category'
DebugCategory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DebugCategory
category
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DebugCategoryFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DebugCategoryFreeMethodInfo DebugCategory signature where
overloadedMethod = debugCategoryFree
instance O.OverloadedMethodInfo DebugCategoryFreeMethodInfo DebugCategory where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.DebugCategory.debugCategoryFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-DebugCategory.html#v:debugCategoryFree"
})
#endif
foreign import ccall "gst_debug_category_get_color" gst_debug_category_get_color ::
Ptr DebugCategory ->
IO Word32
debugCategoryGetColor ::
(B.CallStack.HasCallStack, MonadIO m) =>
DebugCategory
-> m Word32
debugCategoryGetColor :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DebugCategory -> m Word32
debugCategoryGetColor DebugCategory
category = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr DebugCategory
category' <- DebugCategory -> IO (Ptr DebugCategory)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DebugCategory
category
Word32
result <- Ptr DebugCategory -> IO Word32
gst_debug_category_get_color Ptr DebugCategory
category'
DebugCategory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DebugCategory
category
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data DebugCategoryGetColorMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod DebugCategoryGetColorMethodInfo DebugCategory signature where
overloadedMethod = debugCategoryGetColor
instance O.OverloadedMethodInfo DebugCategoryGetColorMethodInfo DebugCategory where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.DebugCategory.debugCategoryGetColor",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-DebugCategory.html#v:debugCategoryGetColor"
})
#endif
foreign import ccall "gst_debug_category_get_description" gst_debug_category_get_description ::
Ptr DebugCategory ->
IO CString
debugCategoryGetDescription ::
(B.CallStack.HasCallStack, MonadIO m) =>
DebugCategory
-> m T.Text
debugCategoryGetDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DebugCategory -> m Text
debugCategoryGetDescription DebugCategory
category = 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
Ptr DebugCategory
category' <- DebugCategory -> IO (Ptr DebugCategory)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DebugCategory
category
CString
result <- Ptr DebugCategory -> IO CString
gst_debug_category_get_description Ptr DebugCategory
category'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"debugCategoryGetDescription" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
DebugCategory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DebugCategory
category
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data DebugCategoryGetDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod DebugCategoryGetDescriptionMethodInfo DebugCategory signature where
overloadedMethod = debugCategoryGetDescription
instance O.OverloadedMethodInfo DebugCategoryGetDescriptionMethodInfo DebugCategory where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.DebugCategory.debugCategoryGetDescription",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-DebugCategory.html#v:debugCategoryGetDescription"
})
#endif
foreign import ccall "gst_debug_category_get_name" gst_debug_category_get_name ::
Ptr DebugCategory ->
IO CString
debugCategoryGetName ::
(B.CallStack.HasCallStack, MonadIO m) =>
DebugCategory
-> m T.Text
debugCategoryGetName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DebugCategory -> m Text
debugCategoryGetName DebugCategory
category = 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
Ptr DebugCategory
category' <- DebugCategory -> IO (Ptr DebugCategory)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DebugCategory
category
CString
result <- Ptr DebugCategory -> IO CString
gst_debug_category_get_name Ptr DebugCategory
category'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"debugCategoryGetName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
DebugCategory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DebugCategory
category
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data DebugCategoryGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod DebugCategoryGetNameMethodInfo DebugCategory signature where
overloadedMethod = debugCategoryGetName
instance O.OverloadedMethodInfo DebugCategoryGetNameMethodInfo DebugCategory where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.DebugCategory.debugCategoryGetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-DebugCategory.html#v:debugCategoryGetName"
})
#endif
foreign import ccall "gst_debug_category_get_threshold" gst_debug_category_get_threshold ::
Ptr DebugCategory ->
IO CUInt
debugCategoryGetThreshold ::
(B.CallStack.HasCallStack, MonadIO m) =>
DebugCategory
-> m Gst.Enums.DebugLevel
debugCategoryGetThreshold :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DebugCategory -> m DebugLevel
debugCategoryGetThreshold DebugCategory
category = IO DebugLevel -> m DebugLevel
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DebugLevel -> m DebugLevel) -> IO DebugLevel -> m DebugLevel
forall a b. (a -> b) -> a -> b
$ do
Ptr DebugCategory
category' <- DebugCategory -> IO (Ptr DebugCategory)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DebugCategory
category
CUInt
result <- Ptr DebugCategory -> IO CUInt
gst_debug_category_get_threshold Ptr DebugCategory
category'
let result' :: DebugLevel
result' = (Int -> DebugLevel
forall a. Enum a => Int -> a
toEnum (Int -> DebugLevel) -> (CUInt -> Int) -> CUInt -> DebugLevel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
DebugCategory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DebugCategory
category
DebugLevel -> IO DebugLevel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DebugLevel
result'
#if defined(ENABLE_OVERLOADING)
data DebugCategoryGetThresholdMethodInfo
instance (signature ~ (m Gst.Enums.DebugLevel), MonadIO m) => O.OverloadedMethod DebugCategoryGetThresholdMethodInfo DebugCategory signature where
overloadedMethod = debugCategoryGetThreshold
instance O.OverloadedMethodInfo DebugCategoryGetThresholdMethodInfo DebugCategory where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.DebugCategory.debugCategoryGetThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-DebugCategory.html#v:debugCategoryGetThreshold"
})
#endif
foreign import ccall "gst_debug_category_reset_threshold" gst_debug_category_reset_threshold ::
Ptr DebugCategory ->
IO ()
debugCategoryResetThreshold ::
(B.CallStack.HasCallStack, MonadIO m) =>
DebugCategory
-> m ()
debugCategoryResetThreshold :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DebugCategory -> m ()
debugCategoryResetThreshold DebugCategory
category = 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 DebugCategory
category' <- DebugCategory -> IO (Ptr DebugCategory)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DebugCategory
category
Ptr DebugCategory -> IO ()
gst_debug_category_reset_threshold Ptr DebugCategory
category'
DebugCategory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DebugCategory
category
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DebugCategoryResetThresholdMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DebugCategoryResetThresholdMethodInfo DebugCategory signature where
overloadedMethod = debugCategoryResetThreshold
instance O.OverloadedMethodInfo DebugCategoryResetThresholdMethodInfo DebugCategory where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.DebugCategory.debugCategoryResetThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-DebugCategory.html#v:debugCategoryResetThreshold"
})
#endif
foreign import ccall "gst_debug_category_set_threshold" gst_debug_category_set_threshold ::
Ptr DebugCategory ->
CUInt ->
IO ()
debugCategorySetThreshold ::
(B.CallStack.HasCallStack, MonadIO m) =>
DebugCategory
-> Gst.Enums.DebugLevel
-> m ()
debugCategorySetThreshold :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DebugCategory -> DebugLevel -> m ()
debugCategorySetThreshold DebugCategory
category DebugLevel
level = 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 DebugCategory
category' <- DebugCategory -> IO (Ptr DebugCategory)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DebugCategory
category
let level' :: CUInt
level' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (DebugLevel -> Int) -> DebugLevel -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DebugLevel -> Int
forall a. Enum a => a -> Int
fromEnum) DebugLevel
level
Ptr DebugCategory -> CUInt -> IO ()
gst_debug_category_set_threshold Ptr DebugCategory
category' CUInt
level'
DebugCategory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DebugCategory
category
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DebugCategorySetThresholdMethodInfo
instance (signature ~ (Gst.Enums.DebugLevel -> m ()), MonadIO m) => O.OverloadedMethod DebugCategorySetThresholdMethodInfo DebugCategory signature where
overloadedMethod = debugCategorySetThreshold
instance O.OverloadedMethodInfo DebugCategorySetThresholdMethodInfo DebugCategory where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.DebugCategory.debugCategorySetThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-DebugCategory.html#v:debugCategorySetThreshold"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveDebugCategoryMethod (t :: Symbol) (o :: *) :: * where
ResolveDebugCategoryMethod "free" o = DebugCategoryFreeMethodInfo
ResolveDebugCategoryMethod "resetThreshold" o = DebugCategoryResetThresholdMethodInfo
ResolveDebugCategoryMethod "getColor" o = DebugCategoryGetColorMethodInfo
ResolveDebugCategoryMethod "getDescription" o = DebugCategoryGetDescriptionMethodInfo
ResolveDebugCategoryMethod "getName" o = DebugCategoryGetNameMethodInfo
ResolveDebugCategoryMethod "getThreshold" o = DebugCategoryGetThresholdMethodInfo
ResolveDebugCategoryMethod "setThreshold" o = DebugCategorySetThresholdMethodInfo
ResolveDebugCategoryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDebugCategoryMethod t DebugCategory, O.OverloadedMethod info DebugCategory p) => OL.IsLabel t (DebugCategory -> 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 ~ ResolveDebugCategoryMethod t DebugCategory, O.OverloadedMethod info DebugCategory p, R.HasField t DebugCategory p) => R.HasField t DebugCategory p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDebugCategoryMethod t DebugCategory, O.OverloadedMethodInfo info DebugCategory) => OL.IsLabel t (O.MethodProxy info DebugCategory) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif