{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vips.Structs.ArgumentClass
(
ArgumentClass(..) ,
newZeroArgumentClass ,
#if defined(ENABLE_OVERLOADING)
ResolveArgumentClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ArgumentClassNeedsstringMethodInfo ,
#endif
argumentClassNeedsstring ,
#if defined(ENABLE_OVERLOADING)
argumentClass_flags ,
#endif
getArgumentClassFlags ,
setArgumentClassFlags ,
#if defined(ENABLE_OVERLOADING)
argumentClass_objectClass ,
#endif
clearArgumentClassObjectClass ,
getArgumentClassObjectClass ,
setArgumentClassObjectClass ,
#if defined(ENABLE_OVERLOADING)
argumentClass_offset ,
#endif
getArgumentClassOffset ,
setArgumentClassOffset ,
#if defined(ENABLE_OVERLOADING)
argumentClass_parent ,
#endif
getArgumentClassParent ,
#if defined(ENABLE_OVERLOADING)
argumentClass_priority ,
#endif
getArgumentClassPriority ,
setArgumentClassPriority ,
) 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.Coerce as Coerce
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
import {-# SOURCE #-} qualified GI.Vips.Flags as Vips.Flags
import {-# SOURCE #-} qualified GI.Vips.Structs.Argument as Vips.Argument
import {-# SOURCE #-} qualified GI.Vips.Structs.ObjectClass as Vips.ObjectClass
newtype ArgumentClass = ArgumentClass (SP.ManagedPtr ArgumentClass)
deriving (ArgumentClass -> ArgumentClass -> Bool
(ArgumentClass -> ArgumentClass -> Bool)
-> (ArgumentClass -> ArgumentClass -> Bool) -> Eq ArgumentClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArgumentClass -> ArgumentClass -> Bool
$c/= :: ArgumentClass -> ArgumentClass -> Bool
== :: ArgumentClass -> ArgumentClass -> Bool
$c== :: ArgumentClass -> ArgumentClass -> Bool
Eq)
instance SP.ManagedPtrNewtype ArgumentClass where
toManagedPtr :: ArgumentClass -> ManagedPtr ArgumentClass
toManagedPtr (ArgumentClass ManagedPtr ArgumentClass
p) = ManagedPtr ArgumentClass
p
instance BoxedPtr ArgumentClass where
boxedPtrCopy :: ArgumentClass -> IO ArgumentClass
boxedPtrCopy = \ArgumentClass
p -> ArgumentClass
-> (Ptr ArgumentClass -> IO ArgumentClass) -> IO ArgumentClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ArgumentClass
p (Int -> Ptr ArgumentClass -> IO (Ptr ArgumentClass)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
32 (Ptr ArgumentClass -> IO (Ptr ArgumentClass))
-> (Ptr ArgumentClass -> IO ArgumentClass)
-> Ptr ArgumentClass
-> IO ArgumentClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ArgumentClass -> ArgumentClass)
-> Ptr ArgumentClass -> IO ArgumentClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ArgumentClass -> ArgumentClass
ArgumentClass)
boxedPtrFree :: ArgumentClass -> IO ()
boxedPtrFree = \ArgumentClass
x -> ArgumentClass -> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ArgumentClass
x Ptr ArgumentClass -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ArgumentClass where
boxedPtrCalloc :: IO (Ptr ArgumentClass)
boxedPtrCalloc = Int -> IO (Ptr ArgumentClass)
forall a. Int -> IO (Ptr a)
callocBytes Int
32
newZeroArgumentClass :: MonadIO m => m ArgumentClass
newZeroArgumentClass :: forall (m :: * -> *). MonadIO m => m ArgumentClass
newZeroArgumentClass = IO ArgumentClass -> m ArgumentClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ArgumentClass -> m ArgumentClass)
-> IO ArgumentClass -> m ArgumentClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr ArgumentClass)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ArgumentClass)
-> (Ptr ArgumentClass -> IO ArgumentClass) -> IO ArgumentClass
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ArgumentClass -> ArgumentClass)
-> Ptr ArgumentClass -> IO ArgumentClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ArgumentClass -> ArgumentClass
ArgumentClass
instance tag ~ 'AttrSet => Constructible ArgumentClass tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ArgumentClass -> ArgumentClass)
-> [AttrOp ArgumentClass tag] -> m ArgumentClass
new ManagedPtr ArgumentClass -> ArgumentClass
_ [AttrOp ArgumentClass tag]
attrs = do
ArgumentClass
o <- m ArgumentClass
forall (m :: * -> *). MonadIO m => m ArgumentClass
newZeroArgumentClass
ArgumentClass -> [AttrOp ArgumentClass 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ArgumentClass
o [AttrOp ArgumentClass tag]
[AttrOp ArgumentClass 'AttrSet]
attrs
ArgumentClass -> m ArgumentClass
forall (m :: * -> *) a. Monad m => a -> m a
return ArgumentClass
o
getArgumentClassParent :: MonadIO m => ArgumentClass -> m Vips.Argument.Argument
getArgumentClassParent :: forall (m :: * -> *). MonadIO m => ArgumentClass -> m Argument
getArgumentClassParent ArgumentClass
s = 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
$ ArgumentClass -> (Ptr ArgumentClass -> IO Argument) -> IO Argument
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO Argument) -> IO Argument)
-> (Ptr ArgumentClass -> IO Argument) -> IO Argument
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
let val :: Ptr Argument
val = Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr Argument
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Vips.Argument.Argument)
Argument
val' <- ((ManagedPtr Argument -> Argument) -> Ptr Argument -> IO Argument
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Argument -> Argument
Vips.Argument.Argument) Ptr Argument
val
Argument -> IO Argument
forall (m :: * -> *) a. Monad m => a -> m a
return Argument
val'
#if defined(ENABLE_OVERLOADING)
data ArgumentClassParentFieldInfo
instance AttrInfo ArgumentClassParentFieldInfo where
type AttrBaseTypeConstraint ArgumentClassParentFieldInfo = (~) ArgumentClass
type AttrAllowedOps ArgumentClassParentFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint ArgumentClassParentFieldInfo = (~) (Ptr Vips.Argument.Argument)
type AttrTransferTypeConstraint ArgumentClassParentFieldInfo = (~)(Ptr Vips.Argument.Argument)
type AttrTransferType ArgumentClassParentFieldInfo = (Ptr Vips.Argument.Argument)
type AttrGetType ArgumentClassParentFieldInfo = Vips.Argument.Argument
type AttrLabel ArgumentClassParentFieldInfo = "parent"
type AttrOrigin ArgumentClassParentFieldInfo = ArgumentClass
attrGet = getArgumentClassParent
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ArgumentClass.parent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:parent"
})
argumentClass_parent :: AttrLabelProxy "parent"
argumentClass_parent = AttrLabelProxy
#endif
getArgumentClassObjectClass :: MonadIO m => ArgumentClass -> m (Maybe Vips.ObjectClass.ObjectClass)
getArgumentClassObjectClass :: forall (m :: * -> *).
MonadIO m =>
ArgumentClass -> m (Maybe ObjectClass)
getArgumentClassObjectClass ArgumentClass
s = IO (Maybe ObjectClass) -> m (Maybe ObjectClass)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClass) -> m (Maybe ObjectClass))
-> IO (Maybe ObjectClass) -> m (Maybe ObjectClass)
forall a b. (a -> b) -> a -> b
$ ArgumentClass
-> (Ptr ArgumentClass -> IO (Maybe ObjectClass))
-> IO (Maybe ObjectClass)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO (Maybe ObjectClass))
-> IO (Maybe ObjectClass))
-> (Ptr ArgumentClass -> IO (Maybe ObjectClass))
-> IO (Maybe ObjectClass)
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
Ptr ObjectClass
val <- Ptr (Ptr ObjectClass) -> IO (Ptr ObjectClass)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr (Ptr ObjectClass)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr Vips.ObjectClass.ObjectClass)
Maybe ObjectClass
result <- Ptr ObjectClass
-> (Ptr ObjectClass -> IO ObjectClass) -> IO (Maybe ObjectClass)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr ObjectClass
val ((Ptr ObjectClass -> IO ObjectClass) -> IO (Maybe ObjectClass))
-> (Ptr ObjectClass -> IO ObjectClass) -> IO (Maybe ObjectClass)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
val' -> do
ObjectClass
val'' <- ((ManagedPtr ObjectClass -> ObjectClass)
-> Ptr ObjectClass -> IO ObjectClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ObjectClass -> ObjectClass
Vips.ObjectClass.ObjectClass) Ptr ObjectClass
val'
ObjectClass -> IO ObjectClass
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClass
val''
Maybe ObjectClass -> IO (Maybe ObjectClass)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClass
result
setArgumentClassObjectClass :: MonadIO m => ArgumentClass -> Ptr Vips.ObjectClass.ObjectClass -> m ()
setArgumentClassObjectClass :: forall (m :: * -> *).
MonadIO m =>
ArgumentClass -> Ptr ObjectClass -> m ()
setArgumentClassObjectClass ArgumentClass
s Ptr ObjectClass
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ArgumentClass -> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO ()) -> IO ())
-> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
Ptr (Ptr ObjectClass) -> Ptr ObjectClass -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr (Ptr ObjectClass)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr ObjectClass
val :: Ptr Vips.ObjectClass.ObjectClass)
clearArgumentClassObjectClass :: MonadIO m => ArgumentClass -> m ()
clearArgumentClassObjectClass :: forall (m :: * -> *). MonadIO m => ArgumentClass -> m ()
clearArgumentClassObjectClass ArgumentClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ArgumentClass -> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO ()) -> IO ())
-> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
Ptr (Ptr ObjectClass) -> Ptr ObjectClass -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr (Ptr ObjectClass)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr ObjectClass
forall a. Ptr a
FP.nullPtr :: Ptr Vips.ObjectClass.ObjectClass)
#if defined(ENABLE_OVERLOADING)
data ArgumentClassObjectClassFieldInfo
instance AttrInfo ArgumentClassObjectClassFieldInfo where
type AttrBaseTypeConstraint ArgumentClassObjectClassFieldInfo = (~) ArgumentClass
type AttrAllowedOps ArgumentClassObjectClassFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ArgumentClassObjectClassFieldInfo = (~) (Ptr Vips.ObjectClass.ObjectClass)
type AttrTransferTypeConstraint ArgumentClassObjectClassFieldInfo = (~)(Ptr Vips.ObjectClass.ObjectClass)
type AttrTransferType ArgumentClassObjectClassFieldInfo = (Ptr Vips.ObjectClass.ObjectClass)
type AttrGetType ArgumentClassObjectClassFieldInfo = Maybe Vips.ObjectClass.ObjectClass
type AttrLabel ArgumentClassObjectClassFieldInfo = "object_class"
type AttrOrigin ArgumentClassObjectClassFieldInfo = ArgumentClass
attrGet = getArgumentClassObjectClass
attrSet = setArgumentClassObjectClass
attrConstruct = undefined
attrClear = clearArgumentClassObjectClass
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ArgumentClass.objectClass"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:objectClass"
})
argumentClass_objectClass :: AttrLabelProxy "objectClass"
argumentClass_objectClass = AttrLabelProxy
#endif
getArgumentClassFlags :: MonadIO m => ArgumentClass -> m [Vips.Flags.ArgumentFlags]
getArgumentClassFlags :: forall (m :: * -> *).
MonadIO m =>
ArgumentClass -> m [ArgumentFlags]
getArgumentClassFlags ArgumentClass
s = IO [ArgumentFlags] -> m [ArgumentFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ArgumentFlags] -> m [ArgumentFlags])
-> IO [ArgumentFlags] -> m [ArgumentFlags]
forall a b. (a -> b) -> a -> b
$ ArgumentClass
-> (Ptr ArgumentClass -> IO [ArgumentFlags]) -> IO [ArgumentFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO [ArgumentFlags]) -> IO [ArgumentFlags])
-> (Ptr ArgumentClass -> IO [ArgumentFlags]) -> IO [ArgumentFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CUInt
let val' :: [ArgumentFlags]
val' = CUInt -> [ArgumentFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
[ArgumentFlags] -> IO [ArgumentFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [ArgumentFlags]
val'
setArgumentClassFlags :: MonadIO m => ArgumentClass -> [Vips.Flags.ArgumentFlags] -> m ()
setArgumentClassFlags :: forall (m :: * -> *).
MonadIO m =>
ArgumentClass -> [ArgumentFlags] -> m ()
setArgumentClassFlags ArgumentClass
s [ArgumentFlags]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ArgumentClass -> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO ()) -> IO ())
-> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
let val' :: CUInt
val' = [ArgumentFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ArgumentFlags]
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data ArgumentClassFlagsFieldInfo
instance AttrInfo ArgumentClassFlagsFieldInfo where
type AttrBaseTypeConstraint ArgumentClassFlagsFieldInfo = (~) ArgumentClass
type AttrAllowedOps ArgumentClassFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ArgumentClassFlagsFieldInfo = (~) [Vips.Flags.ArgumentFlags]
type AttrTransferTypeConstraint ArgumentClassFlagsFieldInfo = (~)[Vips.Flags.ArgumentFlags]
type AttrTransferType ArgumentClassFlagsFieldInfo = [Vips.Flags.ArgumentFlags]
type AttrGetType ArgumentClassFlagsFieldInfo = [Vips.Flags.ArgumentFlags]
type AttrLabel ArgumentClassFlagsFieldInfo = "flags"
type AttrOrigin ArgumentClassFlagsFieldInfo = ArgumentClass
attrGet = getArgumentClassFlags
attrSet = setArgumentClassFlags
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ArgumentClass.flags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:flags"
})
argumentClass_flags :: AttrLabelProxy "flags"
argumentClass_flags = AttrLabelProxy
#endif
getArgumentClassPriority :: MonadIO m => ArgumentClass -> m Int32
getArgumentClassPriority :: forall (m :: * -> *). MonadIO m => ArgumentClass -> m Int32
getArgumentClassPriority ArgumentClass
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
$ ArgumentClass -> (Ptr ArgumentClass -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO Int32) -> IO Int32)
-> (Ptr ArgumentClass -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setArgumentClassPriority :: MonadIO m => ArgumentClass -> Int32 -> m ()
setArgumentClassPriority :: forall (m :: * -> *). MonadIO m => ArgumentClass -> Int32 -> m ()
setArgumentClassPriority ArgumentClass
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
$ ArgumentClass -> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO ()) -> IO ())
-> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data ArgumentClassPriorityFieldInfo
instance AttrInfo ArgumentClassPriorityFieldInfo where
type AttrBaseTypeConstraint ArgumentClassPriorityFieldInfo = (~) ArgumentClass
type AttrAllowedOps ArgumentClassPriorityFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ArgumentClassPriorityFieldInfo = (~) Int32
type AttrTransferTypeConstraint ArgumentClassPriorityFieldInfo = (~)Int32
type AttrTransferType ArgumentClassPriorityFieldInfo = Int32
type AttrGetType ArgumentClassPriorityFieldInfo = Int32
type AttrLabel ArgumentClassPriorityFieldInfo = "priority"
type AttrOrigin ArgumentClassPriorityFieldInfo = ArgumentClass
attrGet = getArgumentClassPriority
attrSet = setArgumentClassPriority
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ArgumentClass.priority"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:priority"
})
argumentClass_priority :: AttrLabelProxy "priority"
argumentClass_priority = AttrLabelProxy
#endif
getArgumentClassOffset :: MonadIO m => ArgumentClass -> m Word32
getArgumentClassOffset :: forall (m :: * -> *). MonadIO m => ArgumentClass -> m Word32
getArgumentClassOffset ArgumentClass
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
$ ArgumentClass -> (Ptr ArgumentClass -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO Word32) -> IO Word32)
-> (Ptr ArgumentClass -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setArgumentClassOffset :: MonadIO m => ArgumentClass -> Word32 -> m ()
setArgumentClassOffset :: forall (m :: * -> *). MonadIO m => ArgumentClass -> Word32 -> m ()
setArgumentClassOffset ArgumentClass
s 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
$ ArgumentClass -> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentClass
s ((Ptr ArgumentClass -> IO ()) -> IO ())
-> (Ptr ArgumentClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentClass
ptr Ptr ArgumentClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data ArgumentClassOffsetFieldInfo
instance AttrInfo ArgumentClassOffsetFieldInfo where
type AttrBaseTypeConstraint ArgumentClassOffsetFieldInfo = (~) ArgumentClass
type AttrAllowedOps ArgumentClassOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint ArgumentClassOffsetFieldInfo = (~) Word32
type AttrTransferTypeConstraint ArgumentClassOffsetFieldInfo = (~)Word32
type AttrTransferType ArgumentClassOffsetFieldInfo = Word32
type AttrGetType ArgumentClassOffsetFieldInfo = Word32
type AttrLabel ArgumentClassOffsetFieldInfo = "offset"
type AttrOrigin ArgumentClassOffsetFieldInfo = ArgumentClass
attrGet = getArgumentClassOffset
attrSet = setArgumentClassOffset
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ArgumentClass.offset"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:offset"
})
argumentClass_offset :: AttrLabelProxy "offset"
argumentClass_offset = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ArgumentClass
type instance O.AttributeList ArgumentClass = ArgumentClassAttributeList
type ArgumentClassAttributeList = ('[ '("parent", ArgumentClassParentFieldInfo), '("objectClass", ArgumentClassObjectClassFieldInfo), '("flags", ArgumentClassFlagsFieldInfo), '("priority", ArgumentClassPriorityFieldInfo), '("offset", ArgumentClassOffsetFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "vips_argument_class_needsstring" vips_argument_class_needsstring ::
Ptr ArgumentClass ->
IO CInt
argumentClassNeedsstring ::
(B.CallStack.HasCallStack, MonadIO m) =>
ArgumentClass
-> m Bool
argumentClassNeedsstring :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ArgumentClass -> m Bool
argumentClassNeedsstring ArgumentClass
argumentClass = 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
$ do
Ptr ArgumentClass
argumentClass' <- ArgumentClass -> IO (Ptr ArgumentClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ArgumentClass
argumentClass
CInt
result <- Ptr ArgumentClass -> IO CInt
vips_argument_class_needsstring Ptr ArgumentClass
argumentClass'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
ArgumentClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ArgumentClass
argumentClass
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ArgumentClassNeedsstringMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod ArgumentClassNeedsstringMethodInfo ArgumentClass signature where
overloadedMethod = argumentClassNeedsstring
instance O.OverloadedMethodInfo ArgumentClassNeedsstringMethodInfo ArgumentClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Vips.Structs.ArgumentClass.argumentClassNeedsstring",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ArgumentClass.html#v:argumentClassNeedsstring"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveArgumentClassMethod (t :: Symbol) (o :: *) :: * where
ResolveArgumentClassMethod "needsstring" o = ArgumentClassNeedsstringMethodInfo
ResolveArgumentClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveArgumentClassMethod t ArgumentClass, O.OverloadedMethod info ArgumentClass p) => OL.IsLabel t (ArgumentClass -> 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 ~ ResolveArgumentClassMethod t ArgumentClass, O.OverloadedMethod info ArgumentClass p, R.HasField t ArgumentClass p) => R.HasField t ArgumentClass p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveArgumentClassMethod t ArgumentClass, O.OverloadedMethodInfo info ArgumentClass) => OL.IsLabel t (O.MethodProxy info ArgumentClass) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif