{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.HarfBuzz.Structs.UserDataKeyT
(
UserDataKeyT(..) ,
newZeroUserDataKeyT ,
#if defined(ENABLE_OVERLOADING)
ResolveUserDataKeyTMethod ,
#endif
) 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.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.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
newtype UserDataKeyT = UserDataKeyT (SP.ManagedPtr UserDataKeyT)
deriving (UserDataKeyT -> UserDataKeyT -> Bool
(UserDataKeyT -> UserDataKeyT -> Bool)
-> (UserDataKeyT -> UserDataKeyT -> Bool) -> Eq UserDataKeyT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserDataKeyT -> UserDataKeyT -> Bool
$c/= :: UserDataKeyT -> UserDataKeyT -> Bool
== :: UserDataKeyT -> UserDataKeyT -> Bool
$c== :: UserDataKeyT -> UserDataKeyT -> Bool
Eq)
instance SP.ManagedPtrNewtype UserDataKeyT where
toManagedPtr :: UserDataKeyT -> ManagedPtr UserDataKeyT
toManagedPtr (UserDataKeyT ManagedPtr UserDataKeyT
p) = ManagedPtr UserDataKeyT
p
foreign import ccall "hb_gobject_user_data_key_get_type" c_hb_gobject_user_data_key_get_type ::
IO GType
type instance O.ParentTypes UserDataKeyT = '[]
instance O.HasParentTypes UserDataKeyT
instance B.Types.TypedObject UserDataKeyT where
glibType :: IO GType
glibType = IO GType
c_hb_gobject_user_data_key_get_type
instance B.Types.GBoxed UserDataKeyT
instance B.GValue.IsGValue UserDataKeyT where
toGValue :: UserDataKeyT -> IO GValue
toGValue UserDataKeyT
o = do
GType
gtype <- IO GType
c_hb_gobject_user_data_key_get_type
UserDataKeyT -> (Ptr UserDataKeyT -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UserDataKeyT
o (GType
-> (GValue -> Ptr UserDataKeyT -> IO ())
-> Ptr UserDataKeyT
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr UserDataKeyT -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO UserDataKeyT
fromGValue GValue
gv = do
Ptr UserDataKeyT
ptr <- GValue -> IO (Ptr UserDataKeyT)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr UserDataKeyT)
(ManagedPtr UserDataKeyT -> UserDataKeyT)
-> Ptr UserDataKeyT -> IO UserDataKeyT
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr UserDataKeyT -> UserDataKeyT
UserDataKeyT Ptr UserDataKeyT
ptr
newZeroUserDataKeyT :: MonadIO m => m UserDataKeyT
newZeroUserDataKeyT :: m UserDataKeyT
newZeroUserDataKeyT = IO UserDataKeyT -> m UserDataKeyT
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO UserDataKeyT -> m UserDataKeyT)
-> IO UserDataKeyT -> m UserDataKeyT
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr UserDataKeyT)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
1 IO (Ptr UserDataKeyT)
-> (Ptr UserDataKeyT -> IO UserDataKeyT) -> IO UserDataKeyT
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr UserDataKeyT -> UserDataKeyT)
-> Ptr UserDataKeyT -> IO UserDataKeyT
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr UserDataKeyT -> UserDataKeyT
UserDataKeyT
instance tag ~ 'AttrSet => Constructible UserDataKeyT tag where
new :: (ManagedPtr UserDataKeyT -> UserDataKeyT)
-> [AttrOp UserDataKeyT tag] -> m UserDataKeyT
new ManagedPtr UserDataKeyT -> UserDataKeyT
_ [AttrOp UserDataKeyT tag]
attrs = do
UserDataKeyT
o <- m UserDataKeyT
forall (m :: * -> *). MonadIO m => m UserDataKeyT
newZeroUserDataKeyT
UserDataKeyT -> [AttrOp UserDataKeyT 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set UserDataKeyT
o [AttrOp UserDataKeyT tag]
[AttrOp UserDataKeyT 'AttrSet]
attrs
UserDataKeyT -> m UserDataKeyT
forall (m :: * -> *) a. Monad m => a -> m a
return UserDataKeyT
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList UserDataKeyT
type instance O.AttributeList UserDataKeyT = UserDataKeyTAttributeList
type UserDataKeyTAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveUserDataKeyTMethod (t :: Symbol) (o :: *) :: * where
ResolveUserDataKeyTMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveUserDataKeyTMethod t UserDataKeyT, O.MethodInfo info UserDataKeyT p) => OL.IsLabel t (UserDataKeyT -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif