{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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.HarfBuzz.Structs.UserDataKeyT
    ( 

-- * Exported types
    UserDataKeyT(..)                        ,
    newZeroUserDataKeyT                     ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#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


-- | Memory-managed wrapper type.
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

-- | Convert 'UserDataKeyT' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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
        
    

-- | Construct a `UserDataKeyT` struct initialized to zero.
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