{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GIRepository.Unions.Argument
(
Argument(..) ,
newZeroArgument ,
noArgument ,
#if defined(ENABLE_OVERLOADING)
ResolveArgumentMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
argument_vBoolean ,
#endif
getArgumentVBoolean ,
setArgumentVBoolean ,
#if defined(ENABLE_OVERLOADING)
argument_vDouble ,
#endif
getArgumentVDouble ,
setArgumentVDouble ,
#if defined(ENABLE_OVERLOADING)
argument_vFloat ,
#endif
getArgumentVFloat ,
setArgumentVFloat ,
#if defined(ENABLE_OVERLOADING)
argument_vInt ,
#endif
getArgumentVInt ,
setArgumentVInt ,
#if defined(ENABLE_OVERLOADING)
argument_vInt16 ,
#endif
getArgumentVInt16 ,
setArgumentVInt16 ,
#if defined(ENABLE_OVERLOADING)
argument_vInt32 ,
#endif
getArgumentVInt32 ,
setArgumentVInt32 ,
#if defined(ENABLE_OVERLOADING)
argument_vInt64 ,
#endif
getArgumentVInt64 ,
setArgumentVInt64 ,
#if defined(ENABLE_OVERLOADING)
argument_vInt8 ,
#endif
getArgumentVInt8 ,
setArgumentVInt8 ,
#if defined(ENABLE_OVERLOADING)
argument_vLong ,
#endif
getArgumentVLong ,
setArgumentVLong ,
#if defined(ENABLE_OVERLOADING)
argument_vPointer ,
#endif
clearArgumentVPointer ,
getArgumentVPointer ,
setArgumentVPointer ,
#if defined(ENABLE_OVERLOADING)
argument_vShort ,
#endif
getArgumentVShort ,
setArgumentVShort ,
#if defined(ENABLE_OVERLOADING)
argument_vSize ,
#endif
getArgumentVSize ,
setArgumentVSize ,
#if defined(ENABLE_OVERLOADING)
argument_vSsize ,
#endif
getArgumentVSsize ,
setArgumentVSsize ,
#if defined(ENABLE_OVERLOADING)
argument_vString ,
#endif
clearArgumentVString ,
getArgumentVString ,
setArgumentVString ,
#if defined(ENABLE_OVERLOADING)
argument_vUint ,
#endif
getArgumentVUint ,
setArgumentVUint ,
#if defined(ENABLE_OVERLOADING)
argument_vUint16 ,
#endif
getArgumentVUint16 ,
setArgumentVUint16 ,
#if defined(ENABLE_OVERLOADING)
argument_vUint32 ,
#endif
getArgumentVUint32 ,
setArgumentVUint32 ,
#if defined(ENABLE_OVERLOADING)
argument_vUint64 ,
#endif
getArgumentVUint64 ,
setArgumentVUint64 ,
#if defined(ENABLE_OVERLOADING)
argument_vUint8 ,
#endif
getArgumentVUint8 ,
setArgumentVUint8 ,
#if defined(ENABLE_OVERLOADING)
argument_vUlong ,
#endif
getArgumentVUlong ,
setArgumentVUlong ,
#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
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
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
noArgument :: Maybe Argument
noArgument :: Maybe Argument
noArgument = Maybe Argument
forall a. Maybe a
Nothing
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'
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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'
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
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'
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
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
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
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 ())
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