{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Stores an argument of varying type

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

module GI.GIRepository.Unions.Argument
    ( 

-- * Exported types
    Argument(..)                            ,
    newZeroArgument                         ,
    noArgument                              ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveArgumentMethod                   ,
#endif




 -- * Properties
-- ** vBoolean #attr:vBoolean#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vBoolean                       ,
#endif
    getArgumentVBoolean                     ,
    setArgumentVBoolean                     ,


-- ** vDouble #attr:vDouble#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vDouble                        ,
#endif
    getArgumentVDouble                      ,
    setArgumentVDouble                      ,


-- ** vFloat #attr:vFloat#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vFloat                         ,
#endif
    getArgumentVFloat                       ,
    setArgumentVFloat                       ,


-- ** vInt #attr:vInt#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vInt                           ,
#endif
    getArgumentVInt                         ,
    setArgumentVInt                         ,


-- ** vInt16 #attr:vInt16#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vInt16                         ,
#endif
    getArgumentVInt16                       ,
    setArgumentVInt16                       ,


-- ** vInt32 #attr:vInt32#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vInt32                         ,
#endif
    getArgumentVInt32                       ,
    setArgumentVInt32                       ,


-- ** vInt64 #attr:vInt64#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vInt64                         ,
#endif
    getArgumentVInt64                       ,
    setArgumentVInt64                       ,


-- ** vInt8 #attr:vInt8#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vInt8                          ,
#endif
    getArgumentVInt8                        ,
    setArgumentVInt8                        ,


-- ** vLong #attr:vLong#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vLong                          ,
#endif
    getArgumentVLong                        ,
    setArgumentVLong                        ,


-- ** vPointer #attr:vPointer#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vPointer                       ,
#endif
    clearArgumentVPointer                   ,
    getArgumentVPointer                     ,
    setArgumentVPointer                     ,


-- ** vShort #attr:vShort#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vShort                         ,
#endif
    getArgumentVShort                       ,
    setArgumentVShort                       ,


-- ** vSize #attr:vSize#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vSize                          ,
#endif
    getArgumentVSize                        ,
    setArgumentVSize                        ,


-- ** vSsize #attr:vSsize#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vSsize                         ,
#endif
    getArgumentVSsize                       ,
    setArgumentVSsize                       ,


-- ** vString #attr:vString#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vString                        ,
#endif
    clearArgumentVString                    ,
    getArgumentVString                      ,
    setArgumentVString                      ,


-- ** vUint #attr:vUint#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vUint                          ,
#endif
    getArgumentVUint                        ,
    setArgumentVUint                        ,


-- ** vUint16 #attr:vUint16#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vUint16                        ,
#endif
    getArgumentVUint16                      ,
    setArgumentVUint16                      ,


-- ** vUint32 #attr:vUint32#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vUint32                        ,
#endif
    getArgumentVUint32                      ,
    setArgumentVUint32                      ,


-- ** vUint64 #attr:vUint64#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vUint64                        ,
#endif
    getArgumentVUint64                      ,
    setArgumentVUint64                      ,


-- ** vUint8 #attr:vUint8#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vUint8                         ,
#endif
    getArgumentVUint8                       ,
    setArgumentVUint8                       ,


-- ** vUlong #attr:vUlong#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vUlong                         ,
#endif
    getArgumentVUlong                       ,
    setArgumentVUlong                       ,


-- ** vUshort #attr:vUshort#
-- | TODO

#if defined(ENABLE_OVERLOADING)
    argument_vUshort                        ,
#endif
    getArgumentVUshort                      ,
    setArgumentVUshort                      ,




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

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

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


-- | A convenience alias for `Nothing` :: `Maybe` `Argument`.
noArgument :: Maybe Argument
noArgument :: Maybe Argument
noArgument = Maybe Argument
forall a. Maybe a
Nothing

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

-- | Set the value of the “@v_boolean@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argument [ #vBoolean 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVBoolean :: MonadIO m => Argument -> Bool -> m ()
setArgumentVBoolean :: Argument -> Bool -> m ()
setArgumentVBoolean s :: Argument
s val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data ArgumentVBooleanFieldInfo
instance AttrInfo ArgumentVBooleanFieldInfo where
    type AttrBaseTypeConstraint ArgumentVBooleanFieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVBooleanFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVBooleanFieldInfo = (~) Bool
    type AttrTransferTypeConstraint ArgumentVBooleanFieldInfo = (~)Bool
    type AttrTransferType ArgumentVBooleanFieldInfo = Bool
    type AttrGetType ArgumentVBooleanFieldInfo = Bool
    type AttrLabel ArgumentVBooleanFieldInfo = "v_boolean"
    type AttrOrigin ArgumentVBooleanFieldInfo = Argument
    attrGet = getArgumentVBoolean
    attrSet = setArgumentVBoolean
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vBoolean :: AttrLabelProxy "vBoolean"
argument_vBoolean = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ArgumentVInt8FieldInfo
instance AttrInfo ArgumentVInt8FieldInfo where
    type AttrBaseTypeConstraint ArgumentVInt8FieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVInt8FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVInt8FieldInfo = (~) Int8
    type AttrTransferTypeConstraint ArgumentVInt8FieldInfo = (~)Int8
    type AttrTransferType ArgumentVInt8FieldInfo = Int8
    type AttrGetType ArgumentVInt8FieldInfo = Int8
    type AttrLabel ArgumentVInt8FieldInfo = "v_int8"
    type AttrOrigin ArgumentVInt8FieldInfo = Argument
    attrGet = getArgumentVInt8
    attrSet = setArgumentVInt8
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vInt8 :: AttrLabelProxy "vInt8"
argument_vInt8 = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ArgumentVUint8FieldInfo
instance AttrInfo ArgumentVUint8FieldInfo where
    type AttrBaseTypeConstraint ArgumentVUint8FieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVUint8FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUint8FieldInfo = (~) Word8
    type AttrTransferTypeConstraint ArgumentVUint8FieldInfo = (~)Word8
    type AttrTransferType ArgumentVUint8FieldInfo = Word8
    type AttrGetType ArgumentVUint8FieldInfo = Word8
    type AttrLabel ArgumentVUint8FieldInfo = "v_uint8"
    type AttrOrigin ArgumentVUint8FieldInfo = Argument
    attrGet = getArgumentVUint8
    attrSet = setArgumentVUint8
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vUint8 :: AttrLabelProxy "vUint8"
argument_vUint8 = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ArgumentVInt16FieldInfo
instance AttrInfo ArgumentVInt16FieldInfo where
    type AttrBaseTypeConstraint ArgumentVInt16FieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVInt16FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVInt16FieldInfo = (~) Int16
    type AttrTransferTypeConstraint ArgumentVInt16FieldInfo = (~)Int16
    type AttrTransferType ArgumentVInt16FieldInfo = Int16
    type AttrGetType ArgumentVInt16FieldInfo = Int16
    type AttrLabel ArgumentVInt16FieldInfo = "v_int16"
    type AttrOrigin ArgumentVInt16FieldInfo = Argument
    attrGet = getArgumentVInt16
    attrSet = setArgumentVInt16
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vInt16 :: AttrLabelProxy "vInt16"
argument_vInt16 = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ArgumentVUint16FieldInfo
instance AttrInfo ArgumentVUint16FieldInfo where
    type AttrBaseTypeConstraint ArgumentVUint16FieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVUint16FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUint16FieldInfo = (~) Word16
    type AttrTransferTypeConstraint ArgumentVUint16FieldInfo = (~)Word16
    type AttrTransferType ArgumentVUint16FieldInfo = Word16
    type AttrGetType ArgumentVUint16FieldInfo = Word16
    type AttrLabel ArgumentVUint16FieldInfo = "v_uint16"
    type AttrOrigin ArgumentVUint16FieldInfo = Argument
    attrGet = getArgumentVUint16
    attrSet = setArgumentVUint16
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vUint16 :: AttrLabelProxy "vUint16"
argument_vUint16 = AttrLabelProxy

#endif


-- | Get the value of the “@v_int32@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argument #vInt32
-- @
getArgumentVInt32 :: MonadIO m => Argument -> m Int32
getArgumentVInt32 :: Argument -> m Int32
getArgumentVInt32 s :: Argument
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
$ Argument -> (Ptr Argument -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Int32) -> IO Int32)
-> (Ptr Argument -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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_int32@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argument [ #vInt32 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVInt32 :: MonadIO m => Argument -> Int32 -> m ()
setArgumentVInt32 :: Argument -> Int32 -> m ()
setArgumentVInt32 s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ArgumentVInt32FieldInfo
instance AttrInfo ArgumentVInt32FieldInfo where
    type AttrBaseTypeConstraint ArgumentVInt32FieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVInt32FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVInt32FieldInfo = (~) Int32
    type AttrTransferTypeConstraint ArgumentVInt32FieldInfo = (~)Int32
    type AttrTransferType ArgumentVInt32FieldInfo = Int32
    type AttrGetType ArgumentVInt32FieldInfo = Int32
    type AttrLabel ArgumentVInt32FieldInfo = "v_int32"
    type AttrOrigin ArgumentVInt32FieldInfo = Argument
    attrGet = getArgumentVInt32
    attrSet = setArgumentVInt32
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vInt32 :: AttrLabelProxy "vInt32"
argument_vInt32 = AttrLabelProxy

#endif


-- | Get the value of the “@v_uint32@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argument #vUint32
-- @
getArgumentVUint32 :: MonadIO m => Argument -> m Word32
getArgumentVUint32 :: Argument -> m Word32
getArgumentVUint32 s :: Argument
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
$ Argument -> (Ptr Argument -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Word32) -> IO Word32)
-> (Ptr Argument -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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_uint32@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argument [ #vUint32 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVUint32 :: MonadIO m => Argument -> Word32 -> m ()
setArgumentVUint32 :: Argument -> Word32 -> m ()
setArgumentVUint32 s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data ArgumentVUint32FieldInfo
instance AttrInfo ArgumentVUint32FieldInfo where
    type AttrBaseTypeConstraint ArgumentVUint32FieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVUint32FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUint32FieldInfo = (~) Word32
    type AttrTransferTypeConstraint ArgumentVUint32FieldInfo = (~)Word32
    type AttrTransferType ArgumentVUint32FieldInfo = Word32
    type AttrGetType ArgumentVUint32FieldInfo = Word32
    type AttrLabel ArgumentVUint32FieldInfo = "v_uint32"
    type AttrOrigin ArgumentVUint32FieldInfo = Argument
    attrGet = getArgumentVUint32
    attrSet = setArgumentVUint32
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vUint32 :: AttrLabelProxy "vUint32"
argument_vUint32 = 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' argument #vInt64
-- @
getArgumentVInt64 :: MonadIO m => Argument -> m Int64
getArgumentVInt64 :: Argument -> m Int64
getArgumentVInt64 s :: Argument
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
$ Argument -> (Ptr Argument -> IO Int64) -> IO Int64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Int64) -> IO Int64)
-> (Ptr Argument -> IO Int64) -> IO Int64
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Int64
val <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vInt64 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVInt64 :: MonadIO m => Argument -> Int64 -> m ()
setArgumentVInt64 :: Argument -> Int64 -> m ()
setArgumentVInt64 s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr Int64 -> Int64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr Int64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Int64
val :: Int64)

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

argument_vInt64 :: AttrLabelProxy "vInt64"
argument_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' argument #vUint64
-- @
getArgumentVUint64 :: MonadIO m => Argument -> m Word64
getArgumentVUint64 :: Argument -> m Word64
getArgumentVUint64 s :: Argument
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
$ Argument -> (Ptr Argument -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Word64) -> IO Word64)
-> (Ptr Argument -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vUint64 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVUint64 :: MonadIO m => Argument -> Word64 -> m ()
setArgumentVUint64 :: Argument -> Word64 -> m ()
setArgumentVUint64 s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Word64
val :: Word64)

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

argument_vUint64 :: AttrLabelProxy "vUint64"
argument_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' argument #vFloat
-- @
getArgumentVFloat :: MonadIO m => Argument -> m Float
getArgumentVFloat :: Argument -> m Float
getArgumentVFloat s :: Argument
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
$ Argument -> (Ptr Argument -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Float) -> IO Float)
-> (Ptr Argument -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vFloat 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVFloat :: MonadIO m => Argument -> Float -> m ()
setArgumentVFloat :: Argument -> Float -> m ()
setArgumentVFloat s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
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 Argument
ptr Ptr Argument -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CFloat
val' :: CFloat)

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

argument_vFloat :: AttrLabelProxy "vFloat"
argument_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' argument #vDouble
-- @
getArgumentVDouble :: MonadIO m => Argument -> m Double
getArgumentVDouble :: Argument -> m Double
getArgumentVDouble s :: Argument
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
$ Argument -> (Ptr Argument -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Double) -> IO Double)
-> (Ptr Argument -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vDouble 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVDouble :: MonadIO m => Argument -> Double -> m ()
setArgumentVDouble :: Argument -> Double -> m ()
setArgumentVDouble s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
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 Argument
ptr Ptr Argument -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CDouble
val' :: CDouble)

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

argument_vDouble :: AttrLabelProxy "vDouble"
argument_vDouble = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ArgumentVShortFieldInfo
instance AttrInfo ArgumentVShortFieldInfo where
    type AttrBaseTypeConstraint ArgumentVShortFieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVShortFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVShortFieldInfo = (~) Int16
    type AttrTransferTypeConstraint ArgumentVShortFieldInfo = (~)Int16
    type AttrTransferType ArgumentVShortFieldInfo = Int16
    type AttrGetType ArgumentVShortFieldInfo = Int16
    type AttrLabel ArgumentVShortFieldInfo = "v_short"
    type AttrOrigin ArgumentVShortFieldInfo = Argument
    attrGet = getArgumentVShort
    attrSet = setArgumentVShort
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vShort :: AttrLabelProxy "vShort"
argument_vShort = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ArgumentVUshortFieldInfo
instance AttrInfo ArgumentVUshortFieldInfo where
    type AttrBaseTypeConstraint ArgumentVUshortFieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVUshortFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVUshortFieldInfo = (~) Word16
    type AttrTransferTypeConstraint ArgumentVUshortFieldInfo = (~)Word16
    type AttrTransferType ArgumentVUshortFieldInfo = Word16
    type AttrGetType ArgumentVUshortFieldInfo = Word16
    type AttrLabel ArgumentVUshortFieldInfo = "v_ushort"
    type AttrOrigin ArgumentVUshortFieldInfo = Argument
    attrGet = getArgumentVUshort
    attrSet = setArgumentVUshort
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vUshort :: AttrLabelProxy "vUshort"
argument_vUshort = AttrLabelProxy

#endif


-- | 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' argument #vInt
-- @
getArgumentVInt :: MonadIO m => Argument -> m Int32
getArgumentVInt :: Argument -> m Int32
getArgumentVInt s :: Argument
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
$ Argument -> (Ptr Argument -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Int32) -> IO Int32)
-> (Ptr Argument -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vInt 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVInt :: MonadIO m => Argument -> Int32 -> m ()
setArgumentVInt :: Argument -> Int32 -> m ()
setArgumentVInt s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Int32
val :: Int32)

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

argument_vInt :: AttrLabelProxy "vInt"
argument_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' argument #vUint
-- @
getArgumentVUint :: MonadIO m => Argument -> m Word32
getArgumentVUint :: Argument -> m Word32
getArgumentVUint s :: Argument
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
$ Argument -> (Ptr Argument -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Word32) -> IO Word32)
-> (Ptr Argument -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vUint 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVUint :: MonadIO m => Argument -> Word32 -> m ()
setArgumentVUint :: Argument -> Word32 -> m ()
setArgumentVUint s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Word32
val :: Word32)

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

argument_vUint :: AttrLabelProxy "vUint"
argument_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' argument #vLong
-- @
getArgumentVLong :: MonadIO m => Argument -> m CLong
getArgumentVLong :: Argument -> m CLong
getArgumentVLong s :: Argument
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
$ Argument -> (Ptr Argument -> IO CLong) -> IO CLong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO CLong) -> IO CLong)
-> (Ptr Argument -> IO CLong) -> IO CLong
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    CLong
val <- Ptr CLong -> IO CLong
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vLong 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVLong :: MonadIO m => Argument -> CLong -> m ()
setArgumentVLong :: Argument -> CLong -> m ()
setArgumentVLong s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr CLong -> CLong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr CLong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CLong
val :: CLong)

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

argument_vLong :: AttrLabelProxy "vLong"
argument_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' argument #vUlong
-- @
getArgumentVUlong :: MonadIO m => Argument -> m CULong
getArgumentVUlong :: Argument -> m CULong
getArgumentVUlong s :: Argument
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
$ Argument -> (Ptr Argument -> IO CULong) -> IO CULong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO CULong) -> IO CULong)
-> (Ptr Argument -> IO CULong) -> IO CULong
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    CULong
val <- Ptr CULong -> IO CULong
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vUlong 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVUlong :: MonadIO m => Argument -> CULong -> m ()
setArgumentVUlong :: Argument -> CULong -> m ()
setArgumentVUlong s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr CULong -> CULong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CULong
val :: CULong)

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

argument_vUlong :: AttrLabelProxy "vUlong"
argument_vUlong = AttrLabelProxy

#endif


-- | Get the value of the “@v_ssize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argument #vSsize
-- @
getArgumentVSsize :: MonadIO m => Argument -> m Int64
getArgumentVSsize :: Argument -> m Int64
getArgumentVSsize s :: Argument
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
$ Argument -> (Ptr Argument -> IO Int64) -> IO Int64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Int64) -> IO Int64)
-> (Ptr Argument -> IO Int64) -> IO Int64
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Int64
val <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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_ssize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argument [ #vSsize 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVSsize :: MonadIO m => Argument -> Int64 -> m ()
setArgumentVSsize :: Argument -> Int64 -> m ()
setArgumentVSsize s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr Int64 -> Int64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr Int64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Int64
val :: Int64)

#if defined(ENABLE_OVERLOADING)
data ArgumentVSsizeFieldInfo
instance AttrInfo ArgumentVSsizeFieldInfo where
    type AttrBaseTypeConstraint ArgumentVSsizeFieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVSsizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVSsizeFieldInfo = (~) Int64
    type AttrTransferTypeConstraint ArgumentVSsizeFieldInfo = (~)Int64
    type AttrTransferType ArgumentVSsizeFieldInfo = Int64
    type AttrGetType ArgumentVSsizeFieldInfo = Int64
    type AttrLabel ArgumentVSsizeFieldInfo = "v_ssize"
    type AttrOrigin ArgumentVSsizeFieldInfo = Argument
    attrGet = getArgumentVSsize
    attrSet = setArgumentVSsize
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vSsize :: AttrLabelProxy "vSsize"
argument_vSsize = AttrLabelProxy

#endif


-- | Get the value of the “@v_size@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argument #vSize
-- @
getArgumentVSize :: MonadIO m => Argument -> m Word64
getArgumentVSize :: Argument -> m Word64
getArgumentVSize s :: Argument
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
$ Argument -> (Ptr Argument -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO Word64) -> IO Word64)
-> (Ptr Argument -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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_size@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argument [ #vSize 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVSize :: MonadIO m => Argument -> Word64 -> m ()
setArgumentVSize :: Argument -> Word64 -> m ()
setArgumentVSize s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Word64
val :: Word64)

#if defined(ENABLE_OVERLOADING)
data ArgumentVSizeFieldInfo
instance AttrInfo ArgumentVSizeFieldInfo where
    type AttrBaseTypeConstraint ArgumentVSizeFieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentVSizeFieldInfo = (~) Word64
    type AttrTransferTypeConstraint ArgumentVSizeFieldInfo = (~)Word64
    type AttrTransferType ArgumentVSizeFieldInfo = Word64
    type AttrGetType ArgumentVSizeFieldInfo = Word64
    type AttrLabel ArgumentVSizeFieldInfo = "v_size"
    type AttrOrigin ArgumentVSizeFieldInfo = Argument
    attrGet = getArgumentVSize
    attrSet = setArgumentVSize
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

argument_vSize :: AttrLabelProxy "vSize"
argument_vSize = AttrLabelProxy

#endif


-- | Get the value of the “@v_string@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argument #vString
-- @
getArgumentVString :: MonadIO m => Argument -> m (Maybe T.Text)
getArgumentVString :: Argument -> m (Maybe Text)
getArgumentVString s :: Argument
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Argument -> (Ptr Argument -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr Argument -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \val' :: CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

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

-- | Set the value of the “@v_string@” 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' #vString
-- @
clearArgumentVString :: MonadIO m => Argument -> m ()
clearArgumentVString :: Argument -> m ()
clearArgumentVString s :: Argument
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data ArgumentVStringFieldInfo
instance AttrInfo ArgumentVStringFieldInfo where
    type AttrBaseTypeConstraint ArgumentVStringFieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVStringFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ArgumentVStringFieldInfo = (~) CString
    type AttrTransferTypeConstraint ArgumentVStringFieldInfo = (~)CString
    type AttrTransferType ArgumentVStringFieldInfo = CString
    type AttrGetType ArgumentVStringFieldInfo = Maybe T.Text
    type AttrLabel ArgumentVStringFieldInfo = "v_string"
    type AttrOrigin ArgumentVStringFieldInfo = Argument
    attrGet = getArgumentVString
    attrSet = setArgumentVString
    attrConstruct = undefined
    attrClear = clearArgumentVString
    attrTransfer _ v = do
        return v

argument_vString :: AttrLabelProxy "vString"
argument_vString = 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' argument #vPointer
-- @
getArgumentVPointer :: MonadIO m => Argument -> m (Ptr ())
getArgumentVPointer :: Argument -> m (Ptr ())
getArgumentVPointer s :: Argument
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
$ Argument -> (Ptr Argument -> IO (Ptr ())) -> IO (Ptr ())
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO (Ptr ())) -> IO (Ptr ()))
-> (Ptr Argument -> IO (Ptr ())) -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr ()
val <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek (Ptr Argument
ptr Ptr Argument -> 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' argument [ #vPointer 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentVPointer :: MonadIO m => Argument -> Ptr () -> m ()
setArgumentVPointer :: Argument -> Ptr () -> m ()
setArgumentVPointer s :: Argument
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
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> 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
-- @
clearArgumentVPointer :: MonadIO m => Argument -> m ()
clearArgumentVPointer :: Argument -> m ()
clearArgumentVPointer s :: Argument
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Argument -> (Ptr Argument -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Argument
s ((Ptr Argument -> IO ()) -> IO ())
-> (Ptr Argument -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr Argument
ptr -> do
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Argument
ptr Ptr Argument -> 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 ArgumentVPointerFieldInfo
instance AttrInfo ArgumentVPointerFieldInfo where
    type AttrBaseTypeConstraint ArgumentVPointerFieldInfo = (~) Argument
    type AttrAllowedOps ArgumentVPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ArgumentVPointerFieldInfo = (~) (Ptr ())
    type AttrTransferTypeConstraint ArgumentVPointerFieldInfo = (~)(Ptr ())
    type AttrTransferType ArgumentVPointerFieldInfo = (Ptr ())
    type AttrGetType ArgumentVPointerFieldInfo = Ptr ()
    type AttrLabel ArgumentVPointerFieldInfo = "v_pointer"
    type AttrOrigin ArgumentVPointerFieldInfo = Argument
    attrGet = getArgumentVPointer
    attrSet = setArgumentVPointer
    attrConstruct = undefined
    attrClear = clearArgumentVPointer
    attrTransfer _ v = do
        return v

argument_vPointer :: AttrLabelProxy "vPointer"
argument_vPointer = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Argument
type instance O.AttributeList Argument = ArgumentAttributeList
type ArgumentAttributeList = ('[ '("vBoolean", ArgumentVBooleanFieldInfo), '("vInt8", ArgumentVInt8FieldInfo), '("vUint8", ArgumentVUint8FieldInfo), '("vInt16", ArgumentVInt16FieldInfo), '("vUint16", ArgumentVUint16FieldInfo), '("vInt32", ArgumentVInt32FieldInfo), '("vUint32", ArgumentVUint32FieldInfo), '("vInt64", ArgumentVInt64FieldInfo), '("vUint64", ArgumentVUint64FieldInfo), '("vFloat", ArgumentVFloatFieldInfo), '("vDouble", ArgumentVDoubleFieldInfo), '("vShort", ArgumentVShortFieldInfo), '("vUshort", ArgumentVUshortFieldInfo), '("vInt", ArgumentVIntFieldInfo), '("vUint", ArgumentVUintFieldInfo), '("vLong", ArgumentVLongFieldInfo), '("vUlong", ArgumentVUlongFieldInfo), '("vSsize", ArgumentVSsizeFieldInfo), '("vSize", ArgumentVSizeFieldInfo), '("vString", ArgumentVStringFieldInfo), '("vPointer", ArgumentVPointerFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif