#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.GObject.Structs.TypeFundamentalInfo
(
TypeFundamentalInfo(..) ,
newZeroTypeFundamentalInfo ,
noTypeFundamentalInfo ,
getTypeFundamentalInfoTypeFlags ,
setTypeFundamentalInfoTypeFlags ,
#if ENABLE_OVERLOADING
typeFundamentalInfo_typeFlags ,
#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.ManagedPtr as B.ManagedPtr
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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags
newtype TypeFundamentalInfo = TypeFundamentalInfo (ManagedPtr TypeFundamentalInfo)
instance WrappedPtr TypeFundamentalInfo where
wrappedPtrCalloc :: IO (Ptr TypeFundamentalInfo)
wrappedPtrCalloc = Int -> IO (Ptr TypeFundamentalInfo)
forall a. Int -> IO (Ptr a)
callocBytes 4
wrappedPtrCopy :: TypeFundamentalInfo -> IO TypeFundamentalInfo
wrappedPtrCopy = \p :: TypeFundamentalInfo
p -> TypeFundamentalInfo
-> (Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo)
-> IO TypeFundamentalInfo
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeFundamentalInfo
p (Int -> Ptr TypeFundamentalInfo -> IO (Ptr TypeFundamentalInfo)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 4 (Ptr TypeFundamentalInfo -> IO (Ptr TypeFundamentalInfo))
-> (Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo)
-> Ptr TypeFundamentalInfo
-> IO TypeFundamentalInfo
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo)
-> Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo
TypeFundamentalInfo)
wrappedPtrFree :: Maybe (FunPtr (Ptr TypeFundamentalInfo -> IO ()))
wrappedPtrFree = FunPtr (Ptr TypeFundamentalInfo -> IO ())
-> Maybe (FunPtr (Ptr TypeFundamentalInfo -> IO ()))
forall a. a -> Maybe a
Just FunPtr (Ptr TypeFundamentalInfo -> IO ())
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free
newZeroTypeFundamentalInfo :: MonadIO m => m TypeFundamentalInfo
newZeroTypeFundamentalInfo :: m TypeFundamentalInfo
newZeroTypeFundamentalInfo = IO TypeFundamentalInfo -> m TypeFundamentalInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeFundamentalInfo -> m TypeFundamentalInfo)
-> IO TypeFundamentalInfo -> m TypeFundamentalInfo
forall a b. (a -> b) -> a -> b
$ IO (Ptr TypeFundamentalInfo)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr TypeFundamentalInfo)
-> (Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo)
-> IO TypeFundamentalInfo
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo)
-> Ptr TypeFundamentalInfo -> IO TypeFundamentalInfo
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo
TypeFundamentalInfo
instance tag ~ 'AttrSet => Constructible TypeFundamentalInfo tag where
new :: (ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo)
-> [AttrOp TypeFundamentalInfo tag] -> m TypeFundamentalInfo
new _ attrs :: [AttrOp TypeFundamentalInfo tag]
attrs = do
TypeFundamentalInfo
o <- m TypeFundamentalInfo
forall (m :: * -> *). MonadIO m => m TypeFundamentalInfo
newZeroTypeFundamentalInfo
TypeFundamentalInfo
-> [AttrOp TypeFundamentalInfo 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set TypeFundamentalInfo
o [AttrOp TypeFundamentalInfo tag]
[AttrOp TypeFundamentalInfo 'AttrSet]
attrs
TypeFundamentalInfo -> m TypeFundamentalInfo
forall (m :: * -> *) a. Monad m => a -> m a
return TypeFundamentalInfo
o
noTypeFundamentalInfo :: Maybe TypeFundamentalInfo
noTypeFundamentalInfo :: Maybe TypeFundamentalInfo
noTypeFundamentalInfo = Maybe TypeFundamentalInfo
forall a. Maybe a
Nothing
getTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> m [GObject.Flags.TypeFundamentalFlags]
getTypeFundamentalInfoTypeFlags :: TypeFundamentalInfo -> m [TypeFundamentalFlags]
getTypeFundamentalInfoTypeFlags s :: TypeFundamentalInfo
s = IO [TypeFundamentalFlags] -> m [TypeFundamentalFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TypeFundamentalFlags] -> m [TypeFundamentalFlags])
-> IO [TypeFundamentalFlags] -> m [TypeFundamentalFlags]
forall a b. (a -> b) -> a -> b
$ TypeFundamentalInfo
-> (Ptr TypeFundamentalInfo -> IO [TypeFundamentalFlags])
-> IO [TypeFundamentalFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeFundamentalInfo
s ((Ptr TypeFundamentalInfo -> IO [TypeFundamentalFlags])
-> IO [TypeFundamentalFlags])
-> (Ptr TypeFundamentalInfo -> IO [TypeFundamentalFlags])
-> IO [TypeFundamentalFlags]
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr TypeFundamentalInfo
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeFundamentalInfo
ptr Ptr TypeFundamentalInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CUInt
let val' :: [TypeFundamentalFlags]
val' = CUInt -> [TypeFundamentalFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
[TypeFundamentalFlags] -> IO [TypeFundamentalFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [TypeFundamentalFlags]
val'
setTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> [GObject.Flags.TypeFundamentalFlags] -> m ()
setTypeFundamentalInfoTypeFlags :: TypeFundamentalInfo -> [TypeFundamentalFlags] -> m ()
setTypeFundamentalInfoTypeFlags s :: TypeFundamentalInfo
s val :: [TypeFundamentalFlags]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TypeFundamentalInfo -> (Ptr TypeFundamentalInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeFundamentalInfo
s ((Ptr TypeFundamentalInfo -> IO ()) -> IO ())
-> (Ptr TypeFundamentalInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr TypeFundamentalInfo
ptr -> do
let val' :: CUInt
val' = [TypeFundamentalFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TypeFundamentalFlags]
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeFundamentalInfo
ptr Ptr TypeFundamentalInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CUInt
val' :: CUInt)
#if ENABLE_OVERLOADING
data TypeFundamentalInfoTypeFlagsFieldInfo
instance AttrInfo TypeFundamentalInfoTypeFlagsFieldInfo where
type AttrAllowedOps TypeFundamentalInfoTypeFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint TypeFundamentalInfoTypeFlagsFieldInfo = (~) [GObject.Flags.TypeFundamentalFlags]
type AttrBaseTypeConstraint TypeFundamentalInfoTypeFlagsFieldInfo = (~) TypeFundamentalInfo
type AttrGetType TypeFundamentalInfoTypeFlagsFieldInfo = [GObject.Flags.TypeFundamentalFlags]
type AttrLabel TypeFundamentalInfoTypeFlagsFieldInfo = "type_flags"
type AttrOrigin TypeFundamentalInfoTypeFlagsFieldInfo = TypeFundamentalInfo
attrGet _ = getTypeFundamentalInfoTypeFlags
attrSet _ = setTypeFundamentalInfoTypeFlags
attrConstruct = undefined
attrClear _ = undefined
typeFundamentalInfo_typeFlags :: AttrLabelProxy "typeFlags"
typeFundamentalInfo_typeFlags = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList TypeFundamentalInfo
type instance O.AttributeList TypeFundamentalInfo = TypeFundamentalInfoAttributeList
type TypeFundamentalInfoAttributeList = ('[ '("typeFlags", TypeFundamentalInfoTypeFlagsFieldInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
type family ResolveTypeFundamentalInfoMethod (t :: Symbol) (o :: *) :: * where
ResolveTypeFundamentalInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTypeFundamentalInfoMethod t TypeFundamentalInfo, O.MethodInfo info TypeFundamentalInfo p) => O.IsLabelProxy t (TypeFundamentalInfo -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveTypeFundamentalInfoMethod t TypeFundamentalInfo, O.MethodInfo info TypeFundamentalInfo p) => O.IsLabel t (TypeFundamentalInfo -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
#endif