{-# 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.GObject.Unions.Value_Data_Union_
    ( 

-- * Exported types
    Value_Data_Union_(..)                   ,
    newZeroValue_Data_Union_                ,
    noValue_Data_Union_                     ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveValue_Data_Union_Method          ,
#endif




 -- * Properties
-- ** vDouble #attr:vDouble#
-- | /No description available in the introspection data./

    getValue_Data_Union_VDouble             ,
    setValue_Data_Union_VDouble             ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vDouble               ,
#endif


-- ** vFloat #attr:vFloat#
-- | /No description available in the introspection data./

    getValue_Data_Union_VFloat              ,
    setValue_Data_Union_VFloat              ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vFloat                ,
#endif


-- ** vInt #attr:vInt#
-- | /No description available in the introspection data./

    getValue_Data_Union_VInt                ,
    setValue_Data_Union_VInt                ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vInt                  ,
#endif


-- ** vInt64 #attr:vInt64#
-- | /No description available in the introspection data./

    getValue_Data_Union_VInt64              ,
    setValue_Data_Union_VInt64              ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vInt64                ,
#endif


-- ** vLong #attr:vLong#
-- | /No description available in the introspection data./

    getValue_Data_Union_VLong               ,
    setValue_Data_Union_VLong               ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vLong                 ,
#endif


-- ** vPointer #attr:vPointer#
-- | /No description available in the introspection data./

    clearValue_Data_Union_VPointer          ,
    getValue_Data_Union_VPointer            ,
    setValue_Data_Union_VPointer            ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vPointer              ,
#endif


-- ** vUint #attr:vUint#
-- | /No description available in the introspection data./

    getValue_Data_Union_VUint               ,
    setValue_Data_Union_VUint               ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vUint                 ,
#endif


-- ** vUint64 #attr:vUint64#
-- | /No description available in the introspection data./

    getValue_Data_Union_VUint64             ,
    setValue_Data_Union_VUint64             ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vUint64               ,
#endif


-- ** vUlong #attr:vUlong#
-- | /No description available in the introspection data./

    getValue_Data_Union_VUlong              ,
    setValue_Data_Union_VUlong              ,
#if defined(ENABLE_OVERLOADING)
    value_Data_Union__vUlong                ,
#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.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 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 Value_Data_Union_ = Value_Data_Union_ (ManagedPtr Value_Data_Union_)
    deriving (Value_Data_Union_ -> Value_Data_Union_ -> Bool
(Value_Data_Union_ -> Value_Data_Union_ -> Bool)
-> (Value_Data_Union_ -> Value_Data_Union_ -> Bool)
-> Eq Value_Data_Union_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Value_Data_Union_ -> Value_Data_Union_ -> Bool
$c/= :: Value_Data_Union_ -> Value_Data_Union_ -> Bool
== :: Value_Data_Union_ -> Value_Data_Union_ -> Bool
$c== :: Value_Data_Union_ -> Value_Data_Union_ -> Bool
Eq)
instance WrappedPtr Value_Data_Union_ where
    wrappedPtrCalloc :: IO (Ptr Value_Data_Union_)
wrappedPtrCalloc = Int -> IO (Ptr Value_Data_Union_)
forall a. Int -> IO (Ptr a)
callocBytes 8
    wrappedPtrCopy :: Value_Data_Union_ -> IO Value_Data_Union_
wrappedPtrCopy = \p :: Value_Data_Union_
p -> Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO Value_Data_Union_)
-> IO Value_Data_Union_
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
p (Int -> Ptr Value_Data_Union_ -> IO (Ptr Value_Data_Union_)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 8 (Ptr Value_Data_Union_ -> IO (Ptr Value_Data_Union_))
-> (Ptr Value_Data_Union_ -> IO Value_Data_Union_)
-> Ptr Value_Data_Union_
-> IO Value_Data_Union_
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr Value_Data_Union_ -> Value_Data_Union_)
-> Ptr Value_Data_Union_ -> IO Value_Data_Union_
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Value_Data_Union_ -> Value_Data_Union_
Value_Data_Union_)
    wrappedPtrFree :: Maybe (GDestroyNotify Value_Data_Union_)
wrappedPtrFree = GDestroyNotify Value_Data_Union_
-> Maybe (GDestroyNotify Value_Data_Union_)
forall a. a -> Maybe a
Just GDestroyNotify Value_Data_Union_
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `Value_Data_Union_` struct initialized to zero.
newZeroValue_Data_Union_ :: MonadIO m => m Value_Data_Union_
newZeroValue_Data_Union_ :: m Value_Data_Union_
newZeroValue_Data_Union_ = IO Value_Data_Union_ -> m Value_Data_Union_
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Value_Data_Union_ -> m Value_Data_Union_)
-> IO Value_Data_Union_ -> m Value_Data_Union_
forall a b. (a -> b) -> a -> b
$ IO (Ptr Value_Data_Union_)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr Value_Data_Union_)
-> (Ptr Value_Data_Union_ -> IO Value_Data_Union_)
-> IO Value_Data_Union_
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Value_Data_Union_ -> Value_Data_Union_)
-> Ptr Value_Data_Union_ -> IO Value_Data_Union_
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Value_Data_Union_ -> Value_Data_Union_
Value_Data_Union_

instance tag ~ 'AttrSet => Constructible Value_Data_Union_ tag where
    new :: (ManagedPtr Value_Data_Union_ -> Value_Data_Union_)
-> [AttrOp Value_Data_Union_ tag] -> m Value_Data_Union_
new _ attrs :: [AttrOp Value_Data_Union_ tag]
attrs = do
        Value_Data_Union_
o <- m Value_Data_Union_
forall (m :: * -> *). MonadIO m => m Value_Data_Union_
newZeroValue_Data_Union_
        Value_Data_Union_ -> [AttrOp Value_Data_Union_ 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Value_Data_Union_
o [AttrOp Value_Data_Union_ tag]
[AttrOp Value_Data_Union_ 'AttrSet]
attrs
        Value_Data_Union_ -> m Value_Data_Union_
forall (m :: * -> *) a. Monad m => a -> m a
return Value_Data_Union_
o


-- | A convenience alias for `Nothing` :: `Maybe` `Value_Data_Union_`.
noValue_Data_Union_ :: Maybe Value_Data_Union_
noValue_Data_Union_ :: Maybe Value_Data_Union_
noValue_Data_Union_ = Maybe Value_Data_Union_
forall a. Maybe a
Nothing

-- | Get the value of the “@v_int@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vInt
-- @
getValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> m Int32
getValue_Data_Union_VInt :: Value_Data_Union_ -> m Int32
getValue_Data_Union_VInt s :: Value_Data_Union_
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO Int32) -> IO Int32)
-> (Ptr Value_Data_Union_ -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@v_int@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vInt 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> Int32 -> m ()
setValue_Data_Union_VInt :: Value_Data_Union_ -> Int32 -> m ()
setValue_Data_Union_VInt s :: Value_Data_Union_
s val :: Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VIntFieldInfo
instance AttrInfo Value_Data_Union_VIntFieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VIntFieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VIntFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VIntFieldInfo = (~) Int32
    type AttrTransferTypeConstraint Value_Data_Union_VIntFieldInfo = (~)Int32
    type AttrTransferType Value_Data_Union_VIntFieldInfo = Int32
    type AttrGetType Value_Data_Union_VIntFieldInfo = Int32
    type AttrLabel Value_Data_Union_VIntFieldInfo = "v_int"
    type AttrOrigin Value_Data_Union_VIntFieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VInt
    attrSet = setValue_Data_Union_VInt
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

value_Data_Union__vInt :: AttrLabelProxy "vInt"
value_Data_Union__vInt = AttrLabelProxy

#endif


-- | Get the value of the “@v_uint@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vUint
-- @
getValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> m Word32
getValue_Data_Union_VUint :: Value_Data_Union_ -> m Word32
getValue_Data_Union_VUint s :: Value_Data_Union_
s = IO Word32 -> m Word32
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
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO Word32) -> IO Word32)
-> (Ptr Value_Data_Union_ -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@v_uint@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vUint 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> Word32 -> m ()
setValue_Data_Union_VUint :: Value_Data_Union_ -> Word32 -> m ()
setValue_Data_Union_VUint s :: Value_Data_Union_
s val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VUintFieldInfo
instance AttrInfo Value_Data_Union_VUintFieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VUintFieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VUintFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VUintFieldInfo = (~) Word32
    type AttrTransferTypeConstraint Value_Data_Union_VUintFieldInfo = (~)Word32
    type AttrTransferType Value_Data_Union_VUintFieldInfo = Word32
    type AttrGetType Value_Data_Union_VUintFieldInfo = Word32
    type AttrLabel Value_Data_Union_VUintFieldInfo = "v_uint"
    type AttrOrigin Value_Data_Union_VUintFieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VUint
    attrSet = setValue_Data_Union_VUint
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

value_Data_Union__vUint :: AttrLabelProxy "vUint"
value_Data_Union__vUint = AttrLabelProxy

#endif


-- | Get the value of the “@v_long@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vLong
-- @
getValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> m CLong
getValue_Data_Union_VLong :: Value_Data_Union_ -> m CLong
getValue_Data_Union_VLong s :: Value_Data_Union_
s = IO CLong -> m CLong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CLong -> m CLong) -> IO CLong -> m CLong
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO CLong) -> IO CLong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO CLong) -> IO CLong)
-> (Ptr Value_Data_Union_ -> IO CLong) -> IO CLong
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    CLong
val <- Ptr CLong -> IO CLong
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr CLong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CLong
    CLong -> IO CLong
forall (m :: * -> *) a. Monad m => a -> m a
return CLong
val

-- | Set the value of the “@v_long@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vLong 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> CLong -> m ()
setValue_Data_Union_VLong :: Value_Data_Union_ -> CLong -> m ()
setValue_Data_Union_VLong s :: Value_Data_Union_
s val :: CLong
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr CLong -> CLong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr CLong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CLong
val :: CLong)

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VLongFieldInfo
instance AttrInfo Value_Data_Union_VLongFieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VLongFieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VLongFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VLongFieldInfo = (~) CLong
    type AttrTransferTypeConstraint Value_Data_Union_VLongFieldInfo = (~)CLong
    type AttrTransferType Value_Data_Union_VLongFieldInfo = CLong
    type AttrGetType Value_Data_Union_VLongFieldInfo = CLong
    type AttrLabel Value_Data_Union_VLongFieldInfo = "v_long"
    type AttrOrigin Value_Data_Union_VLongFieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VLong
    attrSet = setValue_Data_Union_VLong
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

value_Data_Union__vLong :: AttrLabelProxy "vLong"
value_Data_Union__vLong = AttrLabelProxy

#endif


-- | Get the value of the “@v_ulong@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vUlong
-- @
getValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> m CULong
getValue_Data_Union_VUlong :: Value_Data_Union_ -> m CULong
getValue_Data_Union_VUlong s :: Value_Data_Union_
s = IO CULong -> m CULong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO CULong) -> IO CULong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO CULong) -> IO CULong)
-> (Ptr Value_Data_Union_ -> IO CULong) -> IO CULong
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    CULong
val <- Ptr CULong -> IO CULong
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CULong
    CULong -> IO CULong
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val

-- | Set the value of the “@v_ulong@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vUlong 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> CULong -> m ()
setValue_Data_Union_VUlong :: Value_Data_Union_ -> CULong -> m ()
setValue_Data_Union_VUlong s :: Value_Data_Union_
s val :: CULong
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr CULong -> CULong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CULong
val :: CULong)

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VUlongFieldInfo
instance AttrInfo Value_Data_Union_VUlongFieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VUlongFieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VUlongFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VUlongFieldInfo = (~) CULong
    type AttrTransferTypeConstraint Value_Data_Union_VUlongFieldInfo = (~)CULong
    type AttrTransferType Value_Data_Union_VUlongFieldInfo = CULong
    type AttrGetType Value_Data_Union_VUlongFieldInfo = CULong
    type AttrLabel Value_Data_Union_VUlongFieldInfo = "v_ulong"
    type AttrOrigin Value_Data_Union_VUlongFieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VUlong
    attrSet = setValue_Data_Union_VUlong
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

value_Data_Union__vUlong :: AttrLabelProxy "vUlong"
value_Data_Union__vUlong = AttrLabelProxy

#endif


-- | Get the value of the “@v_int64@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vInt64
-- @
getValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> m Int64
getValue_Data_Union_VInt64 :: Value_Data_Union_ -> m Int64
getValue_Data_Union_VInt64 s :: Value_Data_Union_
s = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO Int64) -> IO Int64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO Int64) -> IO Int64)
-> (Ptr Value_Data_Union_ -> IO Int64) -> IO Int64
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Int64
val <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr Int64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO Int64
    Int64 -> IO Int64
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
val

-- | Set the value of the “@v_int64@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vInt64 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> Int64 -> m ()
setValue_Data_Union_VInt64 :: Value_Data_Union_ -> Int64 -> m ()
setValue_Data_Union_VInt64 s :: Value_Data_Union_
s val :: Int64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr Int64 -> Int64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr Int64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Int64
val :: Int64)

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VInt64FieldInfo
instance AttrInfo Value_Data_Union_VInt64FieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VInt64FieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VInt64FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VInt64FieldInfo = (~) Int64
    type AttrTransferTypeConstraint Value_Data_Union_VInt64FieldInfo = (~)Int64
    type AttrTransferType Value_Data_Union_VInt64FieldInfo = Int64
    type AttrGetType Value_Data_Union_VInt64FieldInfo = Int64
    type AttrLabel Value_Data_Union_VInt64FieldInfo = "v_int64"
    type AttrOrigin Value_Data_Union_VInt64FieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VInt64
    attrSet = setValue_Data_Union_VInt64
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

value_Data_Union__vInt64 :: AttrLabelProxy "vInt64"
value_Data_Union__vInt64 = AttrLabelProxy

#endif


-- | Get the value of the “@v_uint64@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vUint64
-- @
getValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> m Word64
getValue_Data_Union_VUint64 :: Value_Data_Union_ -> m Word64
getValue_Data_Union_VUint64 s :: Value_Data_Union_
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO Word64) -> IO Word64)
-> (Ptr Value_Data_Union_ -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO Word64
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val

-- | Set the value of the “@v_uint64@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vUint64 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> Word64 -> m ()
setValue_Data_Union_VUint64 :: Value_Data_Union_ -> Word64 -> m ()
setValue_Data_Union_VUint64 s :: Value_Data_Union_
s val :: Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Word64
val :: Word64)

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VUint64FieldInfo
instance AttrInfo Value_Data_Union_VUint64FieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VUint64FieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VUint64FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VUint64FieldInfo = (~) Word64
    type AttrTransferTypeConstraint Value_Data_Union_VUint64FieldInfo = (~)Word64
    type AttrTransferType Value_Data_Union_VUint64FieldInfo = Word64
    type AttrGetType Value_Data_Union_VUint64FieldInfo = Word64
    type AttrLabel Value_Data_Union_VUint64FieldInfo = "v_uint64"
    type AttrOrigin Value_Data_Union_VUint64FieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VUint64
    attrSet = setValue_Data_Union_VUint64
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

value_Data_Union__vUint64 :: AttrLabelProxy "vUint64"
value_Data_Union__vUint64 = AttrLabelProxy

#endif


-- | Get the value of the “@v_float@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vFloat
-- @
getValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> m Float
getValue_Data_Union_VFloat :: Value_Data_Union_ -> m Float
getValue_Data_Union_VFloat s :: Value_Data_Union_
s = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO Float) -> IO Float)
-> (Ptr Value_Data_Union_ -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@v_float@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vFloat 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> Float -> m ()
setValue_Data_Union_VFloat :: Value_Data_Union_ -> Float -> m ()
setValue_Data_Union_VFloat s :: Value_Data_Union_
s val :: Float
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VFloatFieldInfo
instance AttrInfo Value_Data_Union_VFloatFieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VFloatFieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VFloatFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VFloatFieldInfo = (~) Float
    type AttrTransferTypeConstraint Value_Data_Union_VFloatFieldInfo = (~)Float
    type AttrTransferType Value_Data_Union_VFloatFieldInfo = Float
    type AttrGetType Value_Data_Union_VFloatFieldInfo = Float
    type AttrLabel Value_Data_Union_VFloatFieldInfo = "v_float"
    type AttrOrigin Value_Data_Union_VFloatFieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VFloat
    attrSet = setValue_Data_Union_VFloat
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

value_Data_Union__vFloat :: AttrLabelProxy "vFloat"
value_Data_Union__vFloat = AttrLabelProxy

#endif


-- | Get the value of the “@v_double@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vDouble
-- @
getValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> m Double
getValue_Data_Union_VDouble :: Value_Data_Union_ -> m Double
getValue_Data_Union_VDouble s :: Value_Data_Union_
s = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO Double) -> IO Double)
-> (Ptr Value_Data_Union_ -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@v_double@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vDouble 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> Double -> m ()
setValue_Data_Union_VDouble :: Value_Data_Union_ -> Double -> m ()
setValue_Data_Union_VDouble s :: Value_Data_Union_
s val :: Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VDoubleFieldInfo
instance AttrInfo Value_Data_Union_VDoubleFieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VDoubleFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~) Double
    type AttrTransferTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~)Double
    type AttrTransferType Value_Data_Union_VDoubleFieldInfo = Double
    type AttrGetType Value_Data_Union_VDoubleFieldInfo = Double
    type AttrLabel Value_Data_Union_VDoubleFieldInfo = "v_double"
    type AttrOrigin Value_Data_Union_VDoubleFieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VDouble
    attrSet = setValue_Data_Union_VDouble
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

value_Data_Union__vDouble :: AttrLabelProxy "vDouble"
value_Data_Union__vDouble = AttrLabelProxy

#endif


-- | Get the value of the “@v_pointer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' value_Data_Union_ #vPointer
-- @
getValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m (Ptr ())
getValue_Data_Union_VPointer :: Value_Data_Union_ -> m (Ptr ())
getValue_Data_Union_VPointer s :: Value_Data_Union_
s = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_
-> (Ptr Value_Data_Union_ -> IO (Ptr ())) -> IO (Ptr ())
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO (Ptr ())) -> IO (Ptr ()))
-> (Ptr Value_Data_Union_ -> IO (Ptr ())) -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr ()
val <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO (Ptr ())
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val

-- | Set the value of the “@v_pointer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vPointer 'Data.GI.Base.Attributes.:=' value ]
-- @
setValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> Ptr () -> m ()
setValue_Data_Union_VPointer :: Value_Data_Union_ -> Ptr () -> m ()
setValue_Data_Union_VPointer s :: Value_Data_Union_
s val :: Ptr ()
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Ptr ()
val :: Ptr ())

-- | Set the value of the “@v_pointer@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #vPointer
-- @
clearValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m ()
clearValue_Data_Union_VPointer :: Value_Data_Union_ -> m ()
clearValue_Data_Union_VPointer s :: Value_Data_Union_
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Value_Data_Union_ -> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Value_Data_Union_
s ((Ptr Value_Data_Union_ -> IO ()) -> IO ())
-> (Ptr Value_Data_Union_ -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Value_Data_Union_
ptr -> do
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Value_Data_Union_
ptr Ptr Value_Data_Union_ -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Ptr ()
forall a. Ptr a
FP.nullPtr :: Ptr ())

#if defined(ENABLE_OVERLOADING)
data Value_Data_Union_VPointerFieldInfo
instance AttrInfo Value_Data_Union_VPointerFieldInfo where
    type AttrBaseTypeConstraint Value_Data_Union_VPointerFieldInfo = (~) Value_Data_Union_
    type AttrAllowedOps Value_Data_Union_VPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint Value_Data_Union_VPointerFieldInfo = (~) (Ptr ())
    type AttrTransferTypeConstraint Value_Data_Union_VPointerFieldInfo = (~)(Ptr ())
    type AttrTransferType Value_Data_Union_VPointerFieldInfo = (Ptr ())
    type AttrGetType Value_Data_Union_VPointerFieldInfo = Ptr ()
    type AttrLabel Value_Data_Union_VPointerFieldInfo = "v_pointer"
    type AttrOrigin Value_Data_Union_VPointerFieldInfo = Value_Data_Union_
    attrGet = getValue_Data_Union_VPointer
    attrSet = setValue_Data_Union_VPointer
    attrConstruct = undefined
    attrClear = clearValue_Data_Union_VPointer
    attrTransfer _ v = do
        return v

value_Data_Union__vPointer :: AttrLabelProxy "vPointer"
value_Data_Union__vPointer = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Value_Data_Union_
type instance O.AttributeList Value_Data_Union_ = Value_Data_Union_AttributeList
type Value_Data_Union_AttributeList = ('[ '("vInt", Value_Data_Union_VIntFieldInfo), '("vUint", Value_Data_Union_VUintFieldInfo), '("vLong", Value_Data_Union_VLongFieldInfo), '("vUlong", Value_Data_Union_VUlongFieldInfo), '("vInt64", Value_Data_Union_VInt64FieldInfo), '("vUint64", Value_Data_Union_VUint64FieldInfo), '("vFloat", Value_Data_Union_VFloatFieldInfo), '("vDouble", Value_Data_Union_VDoubleFieldInfo), '("vPointer", Value_Data_Union_VPointerFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveValue_Data_Union_Method (t :: Symbol) (o :: *) :: * where
    ResolveValue_Data_Union_Method l o = O.MethodResolutionFailed l o

instance (info ~ ResolveValue_Data_Union_Method t Value_Data_Union_, O.MethodInfo info Value_Data_Union_ p) => OL.IsLabel t (Value_Data_Union_ -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif