gi-gobject-2.0.18: GI/GObject/Unions/Value_Data_Union_.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.GObject.Unions.Value_Data_Union_
    ( 

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


 -- * Properties
-- ** vDouble #attr:vDouble#
{- | /No description available in the introspection data./
-}
    getValue_Data_Union_VDouble             ,
    setValue_Data_Union_VDouble             ,
#if 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 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 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 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 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 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 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 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 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.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_)
instance WrappedPtr Value_Data_Union_ where
    wrappedPtrCalloc = callocBytes 8
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 8 >=> wrapPtr Value_Data_Union_)
    wrappedPtrFree = Just 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_ = liftIO $ wrappedPtrCalloc >>= wrapPtr Value_Data_Union_

instance tag ~ 'AttrSet => Constructible Value_Data_Union_ tag where
    new _ attrs = do
        o <- newZeroValue_Data_Union_
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `Value_Data_Union_`.
noValue_Data_Union_ :: Maybe Value_Data_Union_
noValue_Data_Union_ = 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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int32)

#if ENABLE_OVERLOADING
data Value_Data_Union_VIntFieldInfo
instance AttrInfo Value_Data_Union_VIntFieldInfo where
    type AttrAllowedOps Value_Data_Union_VIntFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VIntFieldInfo = (~) Int32
    type AttrBaseTypeConstraint Value_Data_Union_VIntFieldInfo = (~) Value_Data_Union_
    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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

#if ENABLE_OVERLOADING
data Value_Data_Union_VUintFieldInfo
instance AttrInfo Value_Data_Union_VUintFieldInfo where
    type AttrAllowedOps Value_Data_Union_VUintFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VUintFieldInfo = (~) Word32
    type AttrBaseTypeConstraint Value_Data_Union_VUintFieldInfo = (~) Value_Data_Union_
    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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CLong
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CLong)

#if ENABLE_OVERLOADING
data Value_Data_Union_VLongFieldInfo
instance AttrInfo Value_Data_Union_VLongFieldInfo where
    type AttrAllowedOps Value_Data_Union_VLongFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VLongFieldInfo = (~) CLong
    type AttrBaseTypeConstraint Value_Data_Union_VLongFieldInfo = (~) Value_Data_Union_
    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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CULong
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CULong)

#if ENABLE_OVERLOADING
data Value_Data_Union_VUlongFieldInfo
instance AttrInfo Value_Data_Union_VUlongFieldInfo where
    type AttrAllowedOps Value_Data_Union_VUlongFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VUlongFieldInfo = (~) CULong
    type AttrBaseTypeConstraint Value_Data_Union_VUlongFieldInfo = (~) Value_Data_Union_
    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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int64
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int64)

#if ENABLE_OVERLOADING
data Value_Data_Union_VInt64FieldInfo
instance AttrInfo Value_Data_Union_VInt64FieldInfo where
    type AttrAllowedOps Value_Data_Union_VInt64FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VInt64FieldInfo = (~) Int64
    type AttrBaseTypeConstraint Value_Data_Union_VInt64FieldInfo = (~) Value_Data_Union_
    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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word64)

#if ENABLE_OVERLOADING
data Value_Data_Union_VUint64FieldInfo
instance AttrInfo Value_Data_Union_VUint64FieldInfo where
    type AttrAllowedOps Value_Data_Union_VUint64FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VUint64FieldInfo = (~) Word64
    type AttrBaseTypeConstraint Value_Data_Union_VUint64FieldInfo = (~) Value_Data_Union_
    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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CFloat
    let val' = realToFrac val
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 0) (val' :: CFloat)

#if ENABLE_OVERLOADING
data Value_Data_Union_VFloatFieldInfo
instance AttrInfo Value_Data_Union_VFloatFieldInfo where
    type AttrAllowedOps Value_Data_Union_VFloatFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VFloatFieldInfo = (~) Float
    type AttrBaseTypeConstraint Value_Data_Union_VFloatFieldInfo = (~) Value_Data_Union_
    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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CDouble
    let val' = realToFrac val
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 0) (val' :: CDouble)

#if ENABLE_OVERLOADING
data Value_Data_Union_VDoubleFieldInfo
instance AttrInfo Value_Data_Union_VDoubleFieldInfo where
    type AttrAllowedOps Value_Data_Union_VDoubleFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~) Double
    type AttrBaseTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~) Value_Data_Union_
    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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ())

#if ENABLE_OVERLOADING
data Value_Data_Union_VPointerFieldInfo
instance AttrInfo Value_Data_Union_VPointerFieldInfo where
    type AttrAllowedOps Value_Data_Union_VPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint Value_Data_Union_VPointerFieldInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint Value_Data_Union_VPointerFieldInfo = (~) Value_Data_Union_
    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

value_Data_Union__vPointer :: AttrLabelProxy "vPointer"
value_Data_Union__vPointer = AttrLabelProxy

#endif



#if 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 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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif