{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) /No description available in the introspection data./ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.GObject.Unions.Value_Data_Union_ ( -- * Exported types Value_Data_Union_(..) , newZeroValue_Data_Union_ , noValue_Data_Union_ , -- * Properties -- ** vDouble #attr:vDouble# {- | /No description available in the introspection data./ -} getValue_Data_Union_VDouble , setValue_Data_Union_VDouble , #if ENABLE_OVERLOADING value_Data_Union__vDouble , #endif -- ** vFloat #attr:vFloat# {- | /No description available in the introspection data./ -} getValue_Data_Union_VFloat , setValue_Data_Union_VFloat , #if ENABLE_OVERLOADING value_Data_Union__vFloat , #endif -- ** vInt #attr:vInt# {- | /No description available in the introspection data./ -} getValue_Data_Union_VInt , setValue_Data_Union_VInt , #if ENABLE_OVERLOADING value_Data_Union__vInt , #endif -- ** vInt64 #attr:vInt64# {- | /No description available in the introspection data./ -} getValue_Data_Union_VInt64 , setValue_Data_Union_VInt64 , #if ENABLE_OVERLOADING value_Data_Union__vInt64 , #endif -- ** vLong #attr:vLong# {- | /No description available in the introspection data./ -} getValue_Data_Union_VLong , setValue_Data_Union_VLong , #if ENABLE_OVERLOADING value_Data_Union__vLong , #endif -- ** vPointer #attr:vPointer# {- | /No description available in the introspection data./ -} clearValue_Data_Union_VPointer , getValue_Data_Union_VPointer , setValue_Data_Union_VPointer , #if ENABLE_OVERLOADING value_Data_Union__vPointer , #endif -- ** vUint #attr:vUint# {- | /No description available in the introspection data./ -} getValue_Data_Union_VUint , setValue_Data_Union_VUint , #if ENABLE_OVERLOADING value_Data_Union__vUint , #endif -- ** vUint64 #attr:vUint64# {- | /No description available in the introspection data./ -} getValue_Data_Union_VUint64 , setValue_Data_Union_VUint64 , #if ENABLE_OVERLOADING value_Data_Union__vUint64 , #endif -- ** vUlong #attr:vUlong# {- | /No description available in the introspection data./ -} getValue_Data_Union_VUlong , setValue_Data_Union_VUlong , #if ENABLE_OVERLOADING value_Data_Union__vUlong , #endif ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL -- | Memory-managed wrapper type. newtype Value_Data_Union_ = Value_Data_Union_ (ManagedPtr Value_Data_Union_) instance WrappedPtr Value_Data_Union_ where wrappedPtrCalloc = callocBytes 8 wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 8 >=> wrapPtr Value_Data_Union_) wrappedPtrFree = Just ptr_to_g_free -- | Construct a `Value_Data_Union_` struct initialized to zero. newZeroValue_Data_Union_ :: MonadIO m => m Value_Data_Union_ newZeroValue_Data_Union_ = liftIO $ wrappedPtrCalloc >>= wrapPtr Value_Data_Union_ instance tag ~ 'AttrSet => Constructible Value_Data_Union_ tag where new _ attrs = do o <- newZeroValue_Data_Union_ GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `Value_Data_Union_`. noValue_Data_Union_ :: Maybe Value_Data_Union_ noValue_Data_Union_ = Nothing {- | Get the value of the “@v_int@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vInt @ -} getValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> m Int32 getValue_Data_Union_VInt s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO Int32 return val {- | Set the value of the “@v_int@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vInt 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> Int32 -> m () setValue_Data_Union_VInt s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: Int32) #if ENABLE_OVERLOADING data Value_Data_Union_VIntFieldInfo instance AttrInfo Value_Data_Union_VIntFieldInfo where type AttrAllowedOps Value_Data_Union_VIntFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint Value_Data_Union_VIntFieldInfo = (~) Int32 type AttrBaseTypeConstraint Value_Data_Union_VIntFieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VIntFieldInfo = Int32 type AttrLabel Value_Data_Union_VIntFieldInfo = "v_int" type AttrOrigin Value_Data_Union_VIntFieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VInt attrSet _ = setValue_Data_Union_VInt attrConstruct = undefined attrClear _ = undefined value_Data_Union__vInt :: AttrLabelProxy "vInt" value_Data_Union__vInt = AttrLabelProxy #endif {- | Get the value of the “@v_uint@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vUint @ -} getValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> m Word32 getValue_Data_Union_VUint s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO Word32 return val {- | Set the value of the “@v_uint@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vUint 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> Word32 -> m () setValue_Data_Union_VUint s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: Word32) #if ENABLE_OVERLOADING data Value_Data_Union_VUintFieldInfo instance AttrInfo Value_Data_Union_VUintFieldInfo where type AttrAllowedOps Value_Data_Union_VUintFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint Value_Data_Union_VUintFieldInfo = (~) Word32 type AttrBaseTypeConstraint Value_Data_Union_VUintFieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VUintFieldInfo = Word32 type AttrLabel Value_Data_Union_VUintFieldInfo = "v_uint" type AttrOrigin Value_Data_Union_VUintFieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VUint attrSet _ = setValue_Data_Union_VUint attrConstruct = undefined attrClear _ = undefined value_Data_Union__vUint :: AttrLabelProxy "vUint" value_Data_Union__vUint = AttrLabelProxy #endif {- | Get the value of the “@v_long@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vLong @ -} getValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> m CLong getValue_Data_Union_VLong s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO CLong return val {- | Set the value of the “@v_long@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vLong 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> CLong -> m () setValue_Data_Union_VLong s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: CLong) #if ENABLE_OVERLOADING data Value_Data_Union_VLongFieldInfo instance AttrInfo Value_Data_Union_VLongFieldInfo where type AttrAllowedOps Value_Data_Union_VLongFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint Value_Data_Union_VLongFieldInfo = (~) CLong type AttrBaseTypeConstraint Value_Data_Union_VLongFieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VLongFieldInfo = CLong type AttrLabel Value_Data_Union_VLongFieldInfo = "v_long" type AttrOrigin Value_Data_Union_VLongFieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VLong attrSet _ = setValue_Data_Union_VLong attrConstruct = undefined attrClear _ = undefined value_Data_Union__vLong :: AttrLabelProxy "vLong" value_Data_Union__vLong = AttrLabelProxy #endif {- | Get the value of the “@v_ulong@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vUlong @ -} getValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> m CULong getValue_Data_Union_VUlong s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO CULong return val {- | Set the value of the “@v_ulong@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vUlong 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> CULong -> m () setValue_Data_Union_VUlong s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: CULong) #if ENABLE_OVERLOADING data Value_Data_Union_VUlongFieldInfo instance AttrInfo Value_Data_Union_VUlongFieldInfo where type AttrAllowedOps Value_Data_Union_VUlongFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint Value_Data_Union_VUlongFieldInfo = (~) CULong type AttrBaseTypeConstraint Value_Data_Union_VUlongFieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VUlongFieldInfo = CULong type AttrLabel Value_Data_Union_VUlongFieldInfo = "v_ulong" type AttrOrigin Value_Data_Union_VUlongFieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VUlong attrSet _ = setValue_Data_Union_VUlong attrConstruct = undefined attrClear _ = undefined value_Data_Union__vUlong :: AttrLabelProxy "vUlong" value_Data_Union__vUlong = AttrLabelProxy #endif {- | Get the value of the “@v_int64@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vInt64 @ -} getValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> m Int64 getValue_Data_Union_VInt64 s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO Int64 return val {- | Set the value of the “@v_int64@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vInt64 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> Int64 -> m () setValue_Data_Union_VInt64 s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: Int64) #if ENABLE_OVERLOADING data Value_Data_Union_VInt64FieldInfo instance AttrInfo Value_Data_Union_VInt64FieldInfo where type AttrAllowedOps Value_Data_Union_VInt64FieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint Value_Data_Union_VInt64FieldInfo = (~) Int64 type AttrBaseTypeConstraint Value_Data_Union_VInt64FieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VInt64FieldInfo = Int64 type AttrLabel Value_Data_Union_VInt64FieldInfo = "v_int64" type AttrOrigin Value_Data_Union_VInt64FieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VInt64 attrSet _ = setValue_Data_Union_VInt64 attrConstruct = undefined attrClear _ = undefined value_Data_Union__vInt64 :: AttrLabelProxy "vInt64" value_Data_Union__vInt64 = AttrLabelProxy #endif {- | Get the value of the “@v_uint64@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vUint64 @ -} getValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> m Word64 getValue_Data_Union_VUint64 s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO Word64 return val {- | Set the value of the “@v_uint64@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vUint64 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> Word64 -> m () setValue_Data_Union_VUint64 s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: Word64) #if ENABLE_OVERLOADING data Value_Data_Union_VUint64FieldInfo instance AttrInfo Value_Data_Union_VUint64FieldInfo where type AttrAllowedOps Value_Data_Union_VUint64FieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint Value_Data_Union_VUint64FieldInfo = (~) Word64 type AttrBaseTypeConstraint Value_Data_Union_VUint64FieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VUint64FieldInfo = Word64 type AttrLabel Value_Data_Union_VUint64FieldInfo = "v_uint64" type AttrOrigin Value_Data_Union_VUint64FieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VUint64 attrSet _ = setValue_Data_Union_VUint64 attrConstruct = undefined attrClear _ = undefined value_Data_Union__vUint64 :: AttrLabelProxy "vUint64" value_Data_Union__vUint64 = AttrLabelProxy #endif {- | Get the value of the “@v_float@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vFloat @ -} getValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> m Float getValue_Data_Union_VFloat s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO CFloat let val' = realToFrac val return val' {- | Set the value of the “@v_float@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vFloat 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> Float -> m () setValue_Data_Union_VFloat s val = liftIO $ withManagedPtr s $ \ptr -> do let val' = realToFrac val poke (ptr `plusPtr` 0) (val' :: CFloat) #if ENABLE_OVERLOADING data Value_Data_Union_VFloatFieldInfo instance AttrInfo Value_Data_Union_VFloatFieldInfo where type AttrAllowedOps Value_Data_Union_VFloatFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint Value_Data_Union_VFloatFieldInfo = (~) Float type AttrBaseTypeConstraint Value_Data_Union_VFloatFieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VFloatFieldInfo = Float type AttrLabel Value_Data_Union_VFloatFieldInfo = "v_float" type AttrOrigin Value_Data_Union_VFloatFieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VFloat attrSet _ = setValue_Data_Union_VFloat attrConstruct = undefined attrClear _ = undefined value_Data_Union__vFloat :: AttrLabelProxy "vFloat" value_Data_Union__vFloat = AttrLabelProxy #endif {- | Get the value of the “@v_double@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vDouble @ -} getValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> m Double getValue_Data_Union_VDouble s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO CDouble let val' = realToFrac val return val' {- | Set the value of the “@v_double@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vDouble 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> Double -> m () setValue_Data_Union_VDouble s val = liftIO $ withManagedPtr s $ \ptr -> do let val' = realToFrac val poke (ptr `plusPtr` 0) (val' :: CDouble) #if ENABLE_OVERLOADING data Value_Data_Union_VDoubleFieldInfo instance AttrInfo Value_Data_Union_VDoubleFieldInfo where type AttrAllowedOps Value_Data_Union_VDoubleFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~) Double type AttrBaseTypeConstraint Value_Data_Union_VDoubleFieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VDoubleFieldInfo = Double type AttrLabel Value_Data_Union_VDoubleFieldInfo = "v_double" type AttrOrigin Value_Data_Union_VDoubleFieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VDouble attrSet _ = setValue_Data_Union_VDouble attrConstruct = undefined attrClear _ = undefined value_Data_Union__vDouble :: AttrLabelProxy "vDouble" value_Data_Union__vDouble = AttrLabelProxy #endif {- | Get the value of the “@v_pointer@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' value_Data_Union_ #vPointer @ -} getValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m (Ptr ()) getValue_Data_Union_VPointer s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO (Ptr ()) return val {- | Set the value of the “@v_pointer@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' value_Data_Union_ [ #vPointer 'Data.GI.Base.Attributes.:=' value ] @ -} setValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> Ptr () -> m () setValue_Data_Union_VPointer s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: Ptr ()) {- | Set the value of the “@v_pointer@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #vPointer @ -} clearValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m () clearValue_Data_Union_VPointer s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ()) #if ENABLE_OVERLOADING data Value_Data_Union_VPointerFieldInfo instance AttrInfo Value_Data_Union_VPointerFieldInfo where type AttrAllowedOps Value_Data_Union_VPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint Value_Data_Union_VPointerFieldInfo = (~) (Ptr ()) type AttrBaseTypeConstraint Value_Data_Union_VPointerFieldInfo = (~) Value_Data_Union_ type AttrGetType Value_Data_Union_VPointerFieldInfo = Ptr () type AttrLabel Value_Data_Union_VPointerFieldInfo = "v_pointer" type AttrOrigin Value_Data_Union_VPointerFieldInfo = Value_Data_Union_ attrGet _ = getValue_Data_Union_VPointer attrSet _ = setValue_Data_Union_VPointer attrConstruct = undefined attrClear _ = clearValue_Data_Union_VPointer value_Data_Union__vPointer :: AttrLabelProxy "vPointer" value_Data_Union__vPointer = AttrLabelProxy #endif #if ENABLE_OVERLOADING instance O.HasAttributeList Value_Data_Union_ type instance O.AttributeList Value_Data_Union_ = Value_Data_Union_AttributeList type Value_Data_Union_AttributeList = ('[ '("vInt", Value_Data_Union_VIntFieldInfo), '("vUint", Value_Data_Union_VUintFieldInfo), '("vLong", Value_Data_Union_VLongFieldInfo), '("vUlong", Value_Data_Union_VUlongFieldInfo), '("vInt64", Value_Data_Union_VInt64FieldInfo), '("vUint64", Value_Data_Union_VUint64FieldInfo), '("vFloat", Value_Data_Union_VFloatFieldInfo), '("vDouble", Value_Data_Union_VDoubleFieldInfo), '("vPointer", Value_Data_Union_VPointerFieldInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING type family ResolveValue_Data_Union_Method (t :: Symbol) (o :: *) :: * where ResolveValue_Data_Union_Method l o = O.MethodResolutionFailed l o instance (info ~ ResolveValue_Data_Union_Method t Value_Data_Union_, O.MethodInfo info Value_Data_Union_ p) => OL.IsLabel t (Value_Data_Union_ -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif