{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.ParamSpecFraction
(
ParamSpecFraction(..) ,
newZeroParamSpecFraction ,
#if defined(ENABLE_OVERLOADING)
ResolveParamSpecFractionMethod ,
#endif
getParamSpecFractionDefDen ,
#if defined(ENABLE_OVERLOADING)
paramSpecFraction_defDen ,
#endif
setParamSpecFractionDefDen ,
getParamSpecFractionDefNum ,
#if defined(ENABLE_OVERLOADING)
paramSpecFraction_defNum ,
#endif
setParamSpecFractionDefNum ,
getParamSpecFractionMaxDen ,
#if defined(ENABLE_OVERLOADING)
paramSpecFraction_maxDen ,
#endif
setParamSpecFractionMaxDen ,
getParamSpecFractionMaxNum ,
#if defined(ENABLE_OVERLOADING)
paramSpecFraction_maxNum ,
#endif
setParamSpecFractionMaxNum ,
getParamSpecFractionMinDen ,
#if defined(ENABLE_OVERLOADING)
paramSpecFraction_minDen ,
#endif
setParamSpecFractionMinDen ,
getParamSpecFractionMinNum ,
#if defined(ENABLE_OVERLOADING)
paramSpecFraction_minNum ,
#endif
setParamSpecFractionMinNum ,
clearParamSpecFractionParentInstance ,
getParamSpecFractionParentInstance ,
#if defined(ENABLE_OVERLOADING)
paramSpecFraction_parentInstance ,
#endif
setParamSpecFractionParentInstance ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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 Control.Monad.IO.Class as MIO
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
import qualified GHC.Records as R
newtype ParamSpecFraction = ParamSpecFraction (SP.ManagedPtr ParamSpecFraction)
deriving (ParamSpecFraction -> ParamSpecFraction -> Bool
(ParamSpecFraction -> ParamSpecFraction -> Bool)
-> (ParamSpecFraction -> ParamSpecFraction -> Bool)
-> Eq ParamSpecFraction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParamSpecFraction -> ParamSpecFraction -> Bool
$c/= :: ParamSpecFraction -> ParamSpecFraction -> Bool
== :: ParamSpecFraction -> ParamSpecFraction -> Bool
$c== :: ParamSpecFraction -> ParamSpecFraction -> Bool
Eq)
instance SP.ManagedPtrNewtype ParamSpecFraction where
toManagedPtr :: ParamSpecFraction -> ManagedPtr ParamSpecFraction
toManagedPtr (ParamSpecFraction ManagedPtr ParamSpecFraction
p) = ManagedPtr ParamSpecFraction
p
instance BoxedPtr ParamSpecFraction where
boxedPtrCopy :: ParamSpecFraction -> IO ParamSpecFraction
boxedPtrCopy = \ParamSpecFraction
p -> ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO ParamSpecFraction)
-> IO ParamSpecFraction
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ParamSpecFraction
p (Int -> Ptr ParamSpecFraction -> IO (Ptr ParamSpecFraction)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
96 (Ptr ParamSpecFraction -> IO (Ptr ParamSpecFraction))
-> (Ptr ParamSpecFraction -> IO ParamSpecFraction)
-> Ptr ParamSpecFraction
-> IO ParamSpecFraction
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ParamSpecFraction -> ParamSpecFraction)
-> Ptr ParamSpecFraction -> IO ParamSpecFraction
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ParamSpecFraction -> ParamSpecFraction
ParamSpecFraction)
boxedPtrFree :: ParamSpecFraction -> IO ()
boxedPtrFree = \ParamSpecFraction
x -> ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ParamSpecFraction
x Ptr ParamSpecFraction -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ParamSpecFraction where
boxedPtrCalloc :: IO (Ptr ParamSpecFraction)
boxedPtrCalloc = Int -> IO (Ptr ParamSpecFraction)
forall a. Int -> IO (Ptr a)
callocBytes Int
96
newZeroParamSpecFraction :: MonadIO m => m ParamSpecFraction
newZeroParamSpecFraction :: forall (m :: * -> *). MonadIO m => m ParamSpecFraction
newZeroParamSpecFraction = IO ParamSpecFraction -> m ParamSpecFraction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ParamSpecFraction -> m ParamSpecFraction)
-> IO ParamSpecFraction -> m ParamSpecFraction
forall a b. (a -> b) -> a -> b
$ IO (Ptr ParamSpecFraction)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ParamSpecFraction)
-> (Ptr ParamSpecFraction -> IO ParamSpecFraction)
-> IO ParamSpecFraction
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ParamSpecFraction -> ParamSpecFraction)
-> Ptr ParamSpecFraction -> IO ParamSpecFraction
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ParamSpecFraction -> ParamSpecFraction
ParamSpecFraction
instance tag ~ 'AttrSet => Constructible ParamSpecFraction tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ParamSpecFraction -> ParamSpecFraction)
-> [AttrOp ParamSpecFraction tag] -> m ParamSpecFraction
new ManagedPtr ParamSpecFraction -> ParamSpecFraction
_ [AttrOp ParamSpecFraction tag]
attrs = do
ParamSpecFraction
o <- m ParamSpecFraction
forall (m :: * -> *). MonadIO m => m ParamSpecFraction
newZeroParamSpecFraction
ParamSpecFraction -> [AttrOp ParamSpecFraction 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ParamSpecFraction
o [AttrOp ParamSpecFraction tag]
[AttrOp ParamSpecFraction 'AttrSet]
attrs
ParamSpecFraction -> m ParamSpecFraction
forall (m :: * -> *) a. Monad m => a -> m a
return ParamSpecFraction
o
getParamSpecFractionParentInstance :: MonadIO m => ParamSpecFraction -> m (Maybe GParamSpec)
getParamSpecFractionParentInstance :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> m (Maybe GParamSpec)
getParamSpecFractionParentInstance ParamSpecFraction
s = IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GParamSpec) -> m (Maybe GParamSpec))
-> IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO (Maybe GParamSpec))
-> IO (Maybe GParamSpec)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO (Maybe GParamSpec))
-> IO (Maybe GParamSpec))
-> (Ptr ParamSpecFraction -> IO (Maybe GParamSpec))
-> IO (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr GParamSpec
val <- Ptr (Ptr GParamSpec) -> IO (Ptr GParamSpec)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr GParamSpec)
Maybe GParamSpec
result <- Ptr GParamSpec
-> (Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr GParamSpec
val ((Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec))
-> (Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ \Ptr GParamSpec
val' -> do
GParamSpec
val'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
val'
GParamSpec -> IO GParamSpec
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
val''
Maybe GParamSpec -> IO (Maybe GParamSpec)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GParamSpec
result
setParamSpecFractionParentInstance :: MonadIO m => ParamSpecFraction -> Ptr GParamSpec -> m ()
setParamSpecFractionParentInstance :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Ptr GParamSpec -> m ()
setParamSpecFractionParentInstance ParamSpecFraction
s Ptr GParamSpec
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr (Ptr GParamSpec) -> Ptr GParamSpec -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr GParamSpec
val :: Ptr GParamSpec)
clearParamSpecFractionParentInstance :: MonadIO m => ParamSpecFraction -> m ()
clearParamSpecFractionParentInstance :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m ()
clearParamSpecFractionParentInstance ParamSpecFraction
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr (Ptr GParamSpec) -> Ptr GParamSpec -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr GParamSpec
forall a. Ptr a
FP.nullPtr :: Ptr GParamSpec)
#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionParentInstanceFieldInfo
instance AttrInfo ParamSpecFractionParentInstanceFieldInfo where
type AttrBaseTypeConstraint ParamSpecFractionParentInstanceFieldInfo = (~) ParamSpecFraction
type AttrAllowedOps ParamSpecFractionParentInstanceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ParamSpecFractionParentInstanceFieldInfo = (~) (Ptr GParamSpec)
type AttrTransferTypeConstraint ParamSpecFractionParentInstanceFieldInfo = (~)(Ptr GParamSpec)
type AttrTransferType ParamSpecFractionParentInstanceFieldInfo = (Ptr GParamSpec)
type AttrGetType ParamSpecFractionParentInstanceFieldInfo = Maybe GParamSpec
type AttrLabel ParamSpecFractionParentInstanceFieldInfo = "parent_instance"
type AttrOrigin ParamSpecFractionParentInstanceFieldInfo = ParamSpecFraction
attrGet = getParamSpecFractionParentInstance
attrSet = setParamSpecFractionParentInstance
attrConstruct = undefined
attrClear = clearParamSpecFractionParentInstance
attrTransfer _ v = do
return v
paramSpecFraction_parentInstance :: AttrLabelProxy "parentInstance"
paramSpecFraction_parentInstance = AttrLabelProxy
#endif
getParamSpecFractionMinNum :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMinNum :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMinNum ParamSpecFraction
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
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setParamSpecFractionMinNum :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMinNum :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMinNum ParamSpecFraction
s 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
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionMinNumFieldInfo
instance AttrInfo ParamSpecFractionMinNumFieldInfo where
type AttrBaseTypeConstraint ParamSpecFractionMinNumFieldInfo = (~) ParamSpecFraction
type AttrAllowedOps ParamSpecFractionMinNumFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ParamSpecFractionMinNumFieldInfo = (~) Int32
type AttrTransferTypeConstraint ParamSpecFractionMinNumFieldInfo = (~)Int32
type AttrTransferType ParamSpecFractionMinNumFieldInfo = Int32
type AttrGetType ParamSpecFractionMinNumFieldInfo = Int32
type AttrLabel ParamSpecFractionMinNumFieldInfo = "min_num"
type AttrOrigin ParamSpecFractionMinNumFieldInfo = ParamSpecFraction
attrGet = getParamSpecFractionMinNum
attrSet = setParamSpecFractionMinNum
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
paramSpecFraction_minNum :: AttrLabelProxy "minNum"
paramSpecFraction_minNum = AttrLabelProxy
#endif
getParamSpecFractionMinDen :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMinDen :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMinDen ParamSpecFraction
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
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
76) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setParamSpecFractionMinDen :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMinDen :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMinDen ParamSpecFraction
s 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
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
76) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionMinDenFieldInfo
instance AttrInfo ParamSpecFractionMinDenFieldInfo where
type AttrBaseTypeConstraint ParamSpecFractionMinDenFieldInfo = (~) ParamSpecFraction
type AttrAllowedOps ParamSpecFractionMinDenFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ParamSpecFractionMinDenFieldInfo = (~) Int32
type AttrTransferTypeConstraint ParamSpecFractionMinDenFieldInfo = (~)Int32
type AttrTransferType ParamSpecFractionMinDenFieldInfo = Int32
type AttrGetType ParamSpecFractionMinDenFieldInfo = Int32
type AttrLabel ParamSpecFractionMinDenFieldInfo = "min_den"
type AttrOrigin ParamSpecFractionMinDenFieldInfo = ParamSpecFraction
attrGet = getParamSpecFractionMinDen
attrSet = setParamSpecFractionMinDen
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
paramSpecFraction_minDen :: AttrLabelProxy "minDen"
paramSpecFraction_minDen = AttrLabelProxy
#endif
getParamSpecFractionMaxNum :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMaxNum :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMaxNum ParamSpecFraction
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
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setParamSpecFractionMaxNum :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMaxNum :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMaxNum ParamSpecFraction
s 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
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionMaxNumFieldInfo
instance AttrInfo ParamSpecFractionMaxNumFieldInfo where
type AttrBaseTypeConstraint ParamSpecFractionMaxNumFieldInfo = (~) ParamSpecFraction
type AttrAllowedOps ParamSpecFractionMaxNumFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ParamSpecFractionMaxNumFieldInfo = (~) Int32
type AttrTransferTypeConstraint ParamSpecFractionMaxNumFieldInfo = (~)Int32
type AttrTransferType ParamSpecFractionMaxNumFieldInfo = Int32
type AttrGetType ParamSpecFractionMaxNumFieldInfo = Int32
type AttrLabel ParamSpecFractionMaxNumFieldInfo = "max_num"
type AttrOrigin ParamSpecFractionMaxNumFieldInfo = ParamSpecFraction
attrGet = getParamSpecFractionMaxNum
attrSet = setParamSpecFractionMaxNum
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
paramSpecFraction_maxNum :: AttrLabelProxy "maxNum"
paramSpecFraction_maxNum = AttrLabelProxy
#endif
getParamSpecFractionMaxDen :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMaxDen :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMaxDen ParamSpecFraction
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
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
84) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setParamSpecFractionMaxDen :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMaxDen :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMaxDen ParamSpecFraction
s 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
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
84) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionMaxDenFieldInfo
instance AttrInfo ParamSpecFractionMaxDenFieldInfo where
type AttrBaseTypeConstraint ParamSpecFractionMaxDenFieldInfo = (~) ParamSpecFraction
type AttrAllowedOps ParamSpecFractionMaxDenFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ParamSpecFractionMaxDenFieldInfo = (~) Int32
type AttrTransferTypeConstraint ParamSpecFractionMaxDenFieldInfo = (~)Int32
type AttrTransferType ParamSpecFractionMaxDenFieldInfo = Int32
type AttrGetType ParamSpecFractionMaxDenFieldInfo = Int32
type AttrLabel ParamSpecFractionMaxDenFieldInfo = "max_den"
type AttrOrigin ParamSpecFractionMaxDenFieldInfo = ParamSpecFraction
attrGet = getParamSpecFractionMaxDen
attrSet = setParamSpecFractionMaxDen
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
paramSpecFraction_maxDen :: AttrLabelProxy "maxDen"
paramSpecFraction_maxDen = AttrLabelProxy
#endif
getParamSpecFractionDefNum :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionDefNum :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionDefNum ParamSpecFraction
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
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setParamSpecFractionDefNum :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionDefNum :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionDefNum ParamSpecFraction
s 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
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionDefNumFieldInfo
instance AttrInfo ParamSpecFractionDefNumFieldInfo where
type AttrBaseTypeConstraint ParamSpecFractionDefNumFieldInfo = (~) ParamSpecFraction
type AttrAllowedOps ParamSpecFractionDefNumFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ParamSpecFractionDefNumFieldInfo = (~) Int32
type AttrTransferTypeConstraint ParamSpecFractionDefNumFieldInfo = (~)Int32
type AttrTransferType ParamSpecFractionDefNumFieldInfo = Int32
type AttrGetType ParamSpecFractionDefNumFieldInfo = Int32
type AttrLabel ParamSpecFractionDefNumFieldInfo = "def_num"
type AttrOrigin ParamSpecFractionDefNumFieldInfo = ParamSpecFraction
attrGet = getParamSpecFractionDefNum
attrSet = setParamSpecFractionDefNum
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
paramSpecFraction_defNum :: AttrLabelProxy "defNum"
paramSpecFraction_defNum = AttrLabelProxy
#endif
getParamSpecFractionDefDen :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionDefDen :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionDefDen ParamSpecFraction
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
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
92) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setParamSpecFractionDefDen :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionDefDen :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionDefDen ParamSpecFraction
s 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
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
92) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionDefDenFieldInfo
instance AttrInfo ParamSpecFractionDefDenFieldInfo where
type AttrBaseTypeConstraint ParamSpecFractionDefDenFieldInfo = (~) ParamSpecFraction
type AttrAllowedOps ParamSpecFractionDefDenFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ParamSpecFractionDefDenFieldInfo = (~) Int32
type AttrTransferTypeConstraint ParamSpecFractionDefDenFieldInfo = (~)Int32
type AttrTransferType ParamSpecFractionDefDenFieldInfo = Int32
type AttrGetType ParamSpecFractionDefDenFieldInfo = Int32
type AttrLabel ParamSpecFractionDefDenFieldInfo = "def_den"
type AttrOrigin ParamSpecFractionDefDenFieldInfo = ParamSpecFraction
attrGet = getParamSpecFractionDefDen
attrSet = setParamSpecFractionDefDen
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
paramSpecFraction_defDen :: AttrLabelProxy "defDen"
paramSpecFraction_defDen = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ParamSpecFraction
type instance O.AttributeList ParamSpecFraction = ParamSpecFractionAttributeList
type ParamSpecFractionAttributeList = ('[ '("parentInstance", ParamSpecFractionParentInstanceFieldInfo), '("minNum", ParamSpecFractionMinNumFieldInfo), '("minDen", ParamSpecFractionMinDenFieldInfo), '("maxNum", ParamSpecFractionMaxNumFieldInfo), '("maxDen", ParamSpecFractionMaxDenFieldInfo), '("defNum", ParamSpecFractionDefNumFieldInfo), '("defDen", ParamSpecFractionDefDenFieldInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveParamSpecFractionMethod (t :: Symbol) (o :: *) :: * where
ResolveParamSpecFractionMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveParamSpecFractionMethod t ParamSpecFraction, O.OverloadedMethod info ParamSpecFraction p) => OL.IsLabel t (ParamSpecFraction -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveParamSpecFractionMethod t ParamSpecFraction, O.OverloadedMethod info ParamSpecFraction p, R.HasField t ParamSpecFraction p) => R.HasField t ParamSpecFraction p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveParamSpecFractionMethod t ParamSpecFraction, O.OverloadedMethodInfo info ParamSpecFraction) => OL.IsLabel t (O.MethodProxy info ParamSpecFraction) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif