{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GObject.Structs.TypeClass
(
TypeClass(..) ,
newZeroTypeClass ,
#if defined(ENABLE_OVERLOADING)
ResolveTypeClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TypeClassAddPrivateMethodInfo ,
#endif
typeClassAddPrivate ,
typeClassAdjustPrivateOffset ,
#if defined(ENABLE_OVERLOADING)
TypeClassGetPrivateMethodInfo ,
#endif
typeClassGetPrivate ,
typeClassPeek ,
#if defined(ENABLE_OVERLOADING)
TypeClassPeekParentMethodInfo ,
#endif
typeClassPeekParent ,
typeClassPeekStatic ,
typeClassRef ,
#if defined(ENABLE_OVERLOADING)
TypeClassUnrefMethodInfo ,
#endif
typeClassUnref ,
) 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
newtype TypeClass = TypeClass (SP.ManagedPtr TypeClass)
deriving (TypeClass -> TypeClass -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeClass -> TypeClass -> Bool
$c/= :: TypeClass -> TypeClass -> Bool
== :: TypeClass -> TypeClass -> Bool
$c== :: TypeClass -> TypeClass -> Bool
Eq)
instance SP.ManagedPtrNewtype TypeClass where
toManagedPtr :: TypeClass -> ManagedPtr TypeClass
toManagedPtr (TypeClass ManagedPtr TypeClass
p) = ManagedPtr TypeClass
p
instance BoxedPtr TypeClass where
boxedPtrCopy :: TypeClass -> IO TypeClass
boxedPtrCopy = \TypeClass
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TypeClass
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
4 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr TypeClass -> TypeClass
TypeClass)
boxedPtrFree :: TypeClass -> IO ()
boxedPtrFree = \TypeClass
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr TypeClass
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr TypeClass where
boxedPtrCalloc :: IO (Ptr TypeClass)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
4
newZeroTypeClass :: MonadIO m => m TypeClass
newZeroTypeClass :: forall (m :: * -> *). MonadIO m => m TypeClass
newZeroTypeClass = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr TypeClass -> TypeClass
TypeClass
instance tag ~ 'AttrSet => Constructible TypeClass tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr TypeClass -> TypeClass)
-> [AttrOp TypeClass tag] -> m TypeClass
new ManagedPtr TypeClass -> TypeClass
_ [AttrOp TypeClass tag]
attrs = do
TypeClass
o <- forall (m :: * -> *). MonadIO m => m TypeClass
newZeroTypeClass
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set TypeClass
o [AttrOp TypeClass tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return TypeClass
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TypeClass
type instance O.AttributeList TypeClass = TypeClassAttributeList
type TypeClassAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_type_class_add_private" g_type_class_add_private ::
Ptr TypeClass ->
Word32 ->
IO ()
{-# DEPRECATED typeClassAddPrivate ["(Since version 2.58)","Use the @/G_ADD_PRIVATE()/@ macro with the @G_DEFINE_*@"," family of macros to add instance private data to a type"] #-}
typeClassAddPrivate ::
(B.CallStack.HasCallStack, MonadIO m) =>
TypeClass
-> Word32
-> m ()
typeClassAddPrivate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TypeClass -> Word32 -> m ()
typeClassAddPrivate TypeClass
gClass Word32
privateSize = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
gClass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
Ptr TypeClass -> Word32 -> IO ()
g_type_class_add_private Ptr TypeClass
gClass' Word32
privateSize
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TypeClassAddPrivateMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod TypeClassAddPrivateMethodInfo TypeClass signature where
overloadedMethod = typeClassAddPrivate
instance O.OverloadedMethodInfo TypeClassAddPrivateMethodInfo TypeClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeClass.typeClassAddPrivate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeClass.html#v:typeClassAddPrivate"
})
#endif
foreign import ccall "g_type_class_get_private" g_type_class_get_private ::
Ptr TypeClass ->
CGType ->
IO (Ptr ())
typeClassGetPrivate ::
(B.CallStack.HasCallStack, MonadIO m) =>
TypeClass
-> GType
-> m (Ptr ())
typeClassGetPrivate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TypeClass -> GType -> m (Ptr ())
typeClassGetPrivate TypeClass
klass GType
privateType = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
klass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
klass
let privateType' :: Word32
privateType' = GType -> Word32
gtypeToCGType GType
privateType
Ptr ()
result <- Ptr TypeClass -> Word32 -> IO (Ptr ())
g_type_class_get_private Ptr TypeClass
klass' Word32
privateType'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
klass
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data TypeClassGetPrivateMethodInfo
instance (signature ~ (GType -> m (Ptr ())), MonadIO m) => O.OverloadedMethod TypeClassGetPrivateMethodInfo TypeClass signature where
overloadedMethod = typeClassGetPrivate
instance O.OverloadedMethodInfo TypeClassGetPrivateMethodInfo TypeClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeClass.typeClassGetPrivate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeClass.html#v:typeClassGetPrivate"
})
#endif
foreign import ccall "g_type_class_peek_parent" g_type_class_peek_parent ::
Ptr TypeClass ->
IO (Ptr TypeClass)
typeClassPeekParent ::
(B.CallStack.HasCallStack, MonadIO m) =>
TypeClass
-> m TypeClass
typeClassPeekParent :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TypeClass -> m TypeClass
typeClassPeekParent TypeClass
gClass = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
gClass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
Ptr TypeClass
result <- Ptr TypeClass -> IO (Ptr TypeClass)
g_type_class_peek_parent Ptr TypeClass
gClass'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"typeClassPeekParent" Ptr TypeClass
result
TypeClass
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
TypeClass) Ptr TypeClass
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
forall (m :: * -> *) a. Monad m => a -> m a
return TypeClass
result'
#if defined(ENABLE_OVERLOADING)
data TypeClassPeekParentMethodInfo
instance (signature ~ (m TypeClass), MonadIO m) => O.OverloadedMethod TypeClassPeekParentMethodInfo TypeClass signature where
overloadedMethod = typeClassPeekParent
instance O.OverloadedMethodInfo TypeClassPeekParentMethodInfo TypeClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeClass.typeClassPeekParent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeClass.html#v:typeClassPeekParent"
})
#endif
foreign import ccall "g_type_class_unref" g_type_class_unref ::
Ptr TypeClass ->
IO ()
typeClassUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
TypeClass
-> m ()
typeClassUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TypeClass -> m ()
typeClassUnref TypeClass
gClass = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TypeClass
gClass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TypeClass
gClass
Ptr TypeClass -> IO ()
g_type_class_unref Ptr TypeClass
gClass'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TypeClass
gClass
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TypeClassUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TypeClassUnrefMethodInfo TypeClass signature where
overloadedMethod = typeClassUnref
instance O.OverloadedMethodInfo TypeClassUnrefMethodInfo TypeClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeClass.typeClassUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeClass.html#v:typeClassUnref"
})
#endif
foreign import ccall "g_type_class_adjust_private_offset" g_type_class_adjust_private_offset ::
Ptr () ->
Int32 ->
IO ()
typeClassAdjustPrivateOffset ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> Int32
-> m ()
typeClassAdjustPrivateOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> Int32 -> m ()
typeClassAdjustPrivateOffset Ptr ()
gClass Int32
privateSizeOrOffset = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr () -> Int32 -> IO ()
g_type_class_adjust_private_offset Ptr ()
gClass Int32
privateSizeOrOffset
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_type_class_peek" g_type_class_peek ::
CGType ->
IO (Ptr TypeClass)
typeClassPeek ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> m TypeClass
typeClassPeek :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> m TypeClass
typeClassPeek GType
type_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let type_' :: Word32
type_' = GType -> Word32
gtypeToCGType GType
type_
Ptr TypeClass
result <- Word32 -> IO (Ptr TypeClass)
g_type_class_peek Word32
type_'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"typeClassPeek" Ptr TypeClass
result
TypeClass
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
TypeClass) Ptr TypeClass
result
forall (m :: * -> *) a. Monad m => a -> m a
return TypeClass
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_type_class_peek_static" g_type_class_peek_static ::
CGType ->
IO (Ptr TypeClass)
typeClassPeekStatic ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> m TypeClass
typeClassPeekStatic :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> m TypeClass
typeClassPeekStatic GType
type_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let type_' :: Word32
type_' = GType -> Word32
gtypeToCGType GType
type_
Ptr TypeClass
result <- Word32 -> IO (Ptr TypeClass)
g_type_class_peek_static Word32
type_'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"typeClassPeekStatic" Ptr TypeClass
result
TypeClass
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
TypeClass) Ptr TypeClass
result
forall (m :: * -> *) a. Monad m => a -> m a
return TypeClass
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_type_class_ref" g_type_class_ref ::
CGType ->
IO (Ptr TypeClass)
typeClassRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> m TypeClass
typeClassRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> m TypeClass
typeClassRef GType
type_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let type_' :: Word32
type_' = GType -> Word32
gtypeToCGType GType
type_
Ptr TypeClass
result <- Word32 -> IO (Ptr TypeClass)
g_type_class_ref Word32
type_'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"typeClassRef" Ptr TypeClass
result
TypeClass
result' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
TypeClass) Ptr TypeClass
result
forall (m :: * -> *) a. Monad m => a -> m a
return TypeClass
result'
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTypeClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTypeClassMethod "addPrivate" o = TypeClassAddPrivateMethodInfo
ResolveTypeClassMethod "peekParent" o = TypeClassPeekParentMethodInfo
ResolveTypeClassMethod "unref" o = TypeClassUnrefMethodInfo
ResolveTypeClassMethod "getPrivate" o = TypeClassGetPrivateMethodInfo
ResolveTypeClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTypeClassMethod t TypeClass, O.OverloadedMethod info TypeClass p) => OL.IsLabel t (TypeClass -> 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 ~ ResolveTypeClassMethod t TypeClass, O.OverloadedMethod info TypeClass p, R.HasField t TypeClass p) => R.HasField t TypeClass p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTypeClassMethod t TypeClass, O.OverloadedMethodInfo info TypeClass) => OL.IsLabel t (O.MethodProxy info TypeClass) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif