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

Stores an argument of varying type
-}

module GI.GIRepository.Unions.Argument
    ( 

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


 -- * Properties
-- ** vBoolean #attr:vBoolean#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vBoolean                       ,
#endif
    getArgumentVBoolean                     ,
    setArgumentVBoolean                     ,


-- ** vDouble #attr:vDouble#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vDouble                        ,
#endif
    getArgumentVDouble                      ,
    setArgumentVDouble                      ,


-- ** vFloat #attr:vFloat#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vFloat                         ,
#endif
    getArgumentVFloat                       ,
    setArgumentVFloat                       ,


-- ** vInt #attr:vInt#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vInt                           ,
#endif
    getArgumentVInt                         ,
    setArgumentVInt                         ,


-- ** vInt16 #attr:vInt16#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vInt16                         ,
#endif
    getArgumentVInt16                       ,
    setArgumentVInt16                       ,


-- ** vInt32 #attr:vInt32#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vInt32                         ,
#endif
    getArgumentVInt32                       ,
    setArgumentVInt32                       ,


-- ** vInt64 #attr:vInt64#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vInt64                         ,
#endif
    getArgumentVInt64                       ,
    setArgumentVInt64                       ,


-- ** vInt8 #attr:vInt8#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vInt8                          ,
#endif
    getArgumentVInt8                        ,
    setArgumentVInt8                        ,


-- ** vLong #attr:vLong#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vLong                          ,
#endif
    getArgumentVLong                        ,
    setArgumentVLong                        ,


-- ** vPointer #attr:vPointer#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vPointer                       ,
#endif
    clearArgumentVPointer                   ,
    getArgumentVPointer                     ,
    setArgumentVPointer                     ,


-- ** vShort #attr:vShort#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vShort                         ,
#endif
    getArgumentVShort                       ,
    setArgumentVShort                       ,


-- ** vSize #attr:vSize#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vSize                          ,
#endif
    getArgumentVSize                        ,
    setArgumentVSize                        ,


-- ** vSsize #attr:vSsize#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vSsize                         ,
#endif
    getArgumentVSsize                       ,
    setArgumentVSsize                       ,


-- ** vString #attr:vString#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vString                        ,
#endif
    clearArgumentVString                    ,
    getArgumentVString                      ,
    setArgumentVString                      ,


-- ** vUint #attr:vUint#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vUint                          ,
#endif
    getArgumentVUint                        ,
    setArgumentVUint                        ,


-- ** vUint16 #attr:vUint16#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vUint16                        ,
#endif
    getArgumentVUint16                      ,
    setArgumentVUint16                      ,


-- ** vUint32 #attr:vUint32#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vUint32                        ,
#endif
    getArgumentVUint32                      ,
    setArgumentVUint32                      ,


-- ** vUint64 #attr:vUint64#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vUint64                        ,
#endif
    getArgumentVUint64                      ,
    setArgumentVUint64                      ,


-- ** vUint8 #attr:vUint8#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vUint8                         ,
#endif
    getArgumentVUint8                       ,
    setArgumentVUint8                       ,


-- ** vUlong #attr:vUlong#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    argument_vUlong                         ,
#endif
    getArgumentVUlong                       ,
    setArgumentVUlong                       ,


-- ** vUshort #attr:vUshort#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP


newtype Argument = Argument (ManagedPtr Argument)
instance WrappedPtr Argument where
    wrappedPtrCalloc = callocBytes 8
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 8 >=> wrapPtr Argument)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `Argument` struct initialized to zero.
newZeroArgument :: MonadIO m => m Argument
newZeroArgument = liftIO $ wrappedPtrCalloc >>= wrapPtr Argument

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


noArgument :: Maybe Argument
noArgument = Nothing

getArgumentVBoolean :: MonadIO m => Argument -> m Bool
getArgumentVBoolean s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CInt
    let val' = (/= 0) val
    return val'

setArgumentVBoolean :: MonadIO m => Argument -> Bool -> m ()
setArgumentVBoolean s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 0) (val' :: CInt)

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

argument_vBoolean :: AttrLabelProxy "vBoolean"
argument_vBoolean = AttrLabelProxy

#endif


getArgumentVInt8 :: MonadIO m => Argument -> m Int8
getArgumentVInt8 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int8
    return val

setArgumentVInt8 :: MonadIO m => Argument -> Int8 -> m ()
setArgumentVInt8 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int8)

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

argument_vInt8 :: AttrLabelProxy "vInt8"
argument_vInt8 = AttrLabelProxy

#endif


getArgumentVUint8 :: MonadIO m => Argument -> m Word8
getArgumentVUint8 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word8
    return val

setArgumentVUint8 :: MonadIO m => Argument -> Word8 -> m ()
setArgumentVUint8 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word8)

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

argument_vUint8 :: AttrLabelProxy "vUint8"
argument_vUint8 = AttrLabelProxy

#endif


getArgumentVInt16 :: MonadIO m => Argument -> m Int16
getArgumentVInt16 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int16
    return val

setArgumentVInt16 :: MonadIO m => Argument -> Int16 -> m ()
setArgumentVInt16 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int16)

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

argument_vInt16 :: AttrLabelProxy "vInt16"
argument_vInt16 = AttrLabelProxy

#endif


getArgumentVUint16 :: MonadIO m => Argument -> m Word16
getArgumentVUint16 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word16
    return val

setArgumentVUint16 :: MonadIO m => Argument -> Word16 -> m ()
setArgumentVUint16 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word16)

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

argument_vUint16 :: AttrLabelProxy "vUint16"
argument_vUint16 = AttrLabelProxy

#endif


getArgumentVInt32 :: MonadIO m => Argument -> m Int32
getArgumentVInt32 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return val

setArgumentVInt32 :: MonadIO m => Argument -> Int32 -> m ()
setArgumentVInt32 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int32)

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

argument_vInt32 :: AttrLabelProxy "vInt32"
argument_vInt32 = AttrLabelProxy

#endif


getArgumentVUint32 :: MonadIO m => Argument -> m Word32
getArgumentVUint32 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

setArgumentVUint32 :: MonadIO m => Argument -> Word32 -> m ()
setArgumentVUint32 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

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

argument_vUint32 :: AttrLabelProxy "vUint32"
argument_vUint32 = AttrLabelProxy

#endif


getArgumentVInt64 :: MonadIO m => Argument -> m Int64
getArgumentVInt64 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int64
    return val

setArgumentVInt64 :: MonadIO m => Argument -> Int64 -> m ()
setArgumentVInt64 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int64)

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

argument_vInt64 :: AttrLabelProxy "vInt64"
argument_vInt64 = AttrLabelProxy

#endif


getArgumentVUint64 :: MonadIO m => Argument -> m Word64
getArgumentVUint64 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

setArgumentVUint64 :: MonadIO m => Argument -> Word64 -> m ()
setArgumentVUint64 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word64)

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

argument_vUint64 :: AttrLabelProxy "vUint64"
argument_vUint64 = AttrLabelProxy

#endif


getArgumentVFloat :: MonadIO m => Argument -> m Float
getArgumentVFloat s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CFloat
    let val' = realToFrac val
    return val'

setArgumentVFloat :: MonadIO m => Argument -> Float -> m ()
setArgumentVFloat s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 0) (val' :: CFloat)

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

argument_vFloat :: AttrLabelProxy "vFloat"
argument_vFloat = AttrLabelProxy

#endif


getArgumentVDouble :: MonadIO m => Argument -> m Double
getArgumentVDouble s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CDouble
    let val' = realToFrac val
    return val'

setArgumentVDouble :: MonadIO m => Argument -> Double -> m ()
setArgumentVDouble s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 0) (val' :: CDouble)

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

argument_vDouble :: AttrLabelProxy "vDouble"
argument_vDouble = AttrLabelProxy

#endif


getArgumentVShort :: MonadIO m => Argument -> m Int16
getArgumentVShort s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int16
    return val

setArgumentVShort :: MonadIO m => Argument -> Int16 -> m ()
setArgumentVShort s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int16)

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

argument_vShort :: AttrLabelProxy "vShort"
argument_vShort = AttrLabelProxy

#endif


getArgumentVUshort :: MonadIO m => Argument -> m Word16
getArgumentVUshort s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word16
    return val

setArgumentVUshort :: MonadIO m => Argument -> Word16 -> m ()
setArgumentVUshort s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word16)

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

argument_vUshort :: AttrLabelProxy "vUshort"
argument_vUshort = AttrLabelProxy

#endif


getArgumentVInt :: MonadIO m => Argument -> m Int32
getArgumentVInt s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return val

setArgumentVInt :: MonadIO m => Argument -> Int32 -> m ()
setArgumentVInt s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int32)

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

argument_vInt :: AttrLabelProxy "vInt"
argument_vInt = AttrLabelProxy

#endif


getArgumentVUint :: MonadIO m => Argument -> m Word32
getArgumentVUint s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

setArgumentVUint :: MonadIO m => Argument -> Word32 -> m ()
setArgumentVUint s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

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

argument_vUint :: AttrLabelProxy "vUint"
argument_vUint = AttrLabelProxy

#endif


getArgumentVLong :: MonadIO m => Argument -> m CLong
getArgumentVLong s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CLong
    return val

setArgumentVLong :: MonadIO m => Argument -> CLong -> m ()
setArgumentVLong s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CLong)

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

argument_vLong :: AttrLabelProxy "vLong"
argument_vLong = AttrLabelProxy

#endif


getArgumentVUlong :: MonadIO m => Argument -> m CULong
getArgumentVUlong s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CULong
    return val

setArgumentVUlong :: MonadIO m => Argument -> CULong -> m ()
setArgumentVUlong s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CULong)

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

argument_vUlong :: AttrLabelProxy "vUlong"
argument_vUlong = AttrLabelProxy

#endif


getArgumentVSsize :: MonadIO m => Argument -> m Int64
getArgumentVSsize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int64
    return val

setArgumentVSsize :: MonadIO m => Argument -> Int64 -> m ()
setArgumentVSsize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int64)

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

argument_vSsize :: AttrLabelProxy "vSsize"
argument_vSsize = AttrLabelProxy

#endif


getArgumentVSize :: MonadIO m => Argument -> m Word64
getArgumentVSize s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

setArgumentVSize :: MonadIO m => Argument -> Word64 -> m ()
setArgumentVSize s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word64)

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

argument_vSize :: AttrLabelProxy "vSize"
argument_vSize = AttrLabelProxy

#endif


getArgumentVString :: MonadIO m => Argument -> m (Maybe T.Text)
getArgumentVString s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setArgumentVString :: MonadIO m => Argument -> CString -> m ()
setArgumentVString s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CString)

clearArgumentVString :: MonadIO m => Argument -> m ()
clearArgumentVString s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: CString)

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

argument_vString :: AttrLabelProxy "vString"
argument_vString = AttrLabelProxy

#endif


getArgumentVPointer :: MonadIO m => Argument -> m (Ptr ())
getArgumentVPointer s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
    return val

setArgumentVPointer :: MonadIO m => Argument -> Ptr () -> m ()
setArgumentVPointer s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Ptr ())

clearArgumentVPointer :: MonadIO m => Argument -> m ()
clearArgumentVPointer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ())

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ArgumentVPointerFieldInfo
instance AttrInfo ArgumentVPointerFieldInfo where
    type AttrAllowedOps ArgumentVPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ArgumentVPointerFieldInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint ArgumentVPointerFieldInfo = (~) Argument
    type AttrGetType ArgumentVPointerFieldInfo = Ptr ()
    type AttrLabel ArgumentVPointerFieldInfo = "v_pointer"
    type AttrOrigin ArgumentVPointerFieldInfo = Argument
    attrGet _ = getArgumentVPointer
    attrSet _ = setArgumentVPointer
    attrConstruct = undefined
    attrClear _ = clearArgumentVPointer

argument_vPointer :: AttrLabelProxy "vPointer"
argument_vPointer = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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) && !defined(__HADDOCK_VERSION__)
type family ResolveArgumentMethod (t :: Symbol) (o :: *) :: * where
    ResolveArgumentMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveArgumentMethod t Argument, O.MethodInfo info Argument p) => O.IsLabelProxy t (Argument -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

#endif