{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Vips.Structs.ArgumentClass
    ( 

-- * Exported types
    ArgumentClass(..)                       ,
    newZeroArgumentClass                    ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [needsstring]("GI.Vips.Structs.ArgumentClass#g:method:needsstring").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveArgumentClassMethod              ,
#endif

-- ** needsstring #method:needsstring#

#if defined(ENABLE_OVERLOADING)
    ArgumentClassNeedsstringMethodInfo      ,
#endif
    argumentClassNeedsstring                ,




 -- * Properties


-- ** flags #attr:flags#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    argumentClass_flags                     ,
#endif
    getArgumentClassFlags                   ,
    setArgumentClassFlags                   ,


-- ** objectClass #attr:objectClass#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    argumentClass_objectClass               ,
#endif
    clearArgumentClassObjectClass           ,
    getArgumentClassObjectClass             ,
    setArgumentClassObjectClass             ,


-- ** offset #attr:offset#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    argumentClass_offset                    ,
#endif
    getArgumentClassOffset                  ,
    setArgumentClassOffset                  ,


-- ** parent #attr:parent#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    argumentClass_parent                    ,
#endif
    getArgumentClassParent                  ,


-- ** priority #attr:priority#
-- | /No description available in the introspection data./

#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.GHashTable as B.GHT
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.Kind as DK
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

-- | Memory-managed wrapper type.
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
$c== :: ArgumentClass -> ArgumentClass -> Bool
== :: ArgumentClass -> ArgumentClass -> Bool
$c/= :: ArgumentClass -> ArgumentClass -> Bool
/= :: 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


-- | Construct a `ArgumentClass` struct initialized to zero.
newZeroArgumentClass :: MonadIO m => m ArgumentClass
newZeroArgumentClass :: forall (m :: * -> *). MonadIO m => m ArgumentClass
newZeroArgumentClass = IO ArgumentClass -> m ArgumentClass
forall a. IO a -> m a
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 a b. IO a -> (a -> IO b) -> IO b
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 a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ArgumentClass
o


-- | Get the value of the “@parent@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentClass #parent
-- @
getArgumentClassParent :: MonadIO m => ArgumentClass -> m Vips.Argument.Argument
getArgumentClassParent :: forall (m :: * -> *). MonadIO m => ArgumentClass -> m Argument
getArgumentClassParent ArgumentClass
s = IO Argument -> m Argument
forall a. IO a -> m a
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 a. a -> IO a
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.4/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:parent"
        })

argumentClass_parent :: AttrLabelProxy "parent"
argumentClass_parent = AttrLabelProxy

#endif


-- | Get the value of the “@object_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentClass #objectClass
-- @
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 a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClass
val''
    Maybe ObjectClass -> IO (Maybe ObjectClass)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClass
result

-- | Set the value of the “@object_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentClass [ #objectClass 'Data.GI.Base.Attributes.:=' value ]
-- @
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 a. IO a -> m a
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)

-- | Set the value of the “@object_class@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #objectClass
-- @
clearArgumentClassObjectClass :: MonadIO m => ArgumentClass -> m ()
clearArgumentClassObjectClass :: forall (m :: * -> *). MonadIO m => ArgumentClass -> m ()
clearArgumentClassObjectClass ArgumentClass
s = IO () -> m ()
forall a. IO a -> m a
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.4/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:objectClass"
        })

argumentClass_objectClass :: AttrLabelProxy "objectClass"
argumentClass_objectClass = AttrLabelProxy

#endif


-- | Get the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentClass #flags
-- @
getArgumentClassFlags :: MonadIO m => ArgumentClass -> m [Vips.Flags.ArgumentFlags]
getArgumentClassFlags :: forall (m :: * -> *).
MonadIO m =>
ArgumentClass -> m [ArgumentFlags]
getArgumentClassFlags ArgumentClass
s = IO [ArgumentFlags] -> m [ArgumentFlags]
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ArgumentFlags]
val'

-- | Set the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentClass [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentClassFlags :: MonadIO m => ArgumentClass -> [Vips.Flags.ArgumentFlags] -> m ()
setArgumentClassFlags :: forall (m :: * -> *).
MonadIO m =>
ArgumentClass -> [ArgumentFlags] -> m ()
setArgumentClassFlags ArgumentClass
s [ArgumentFlags]
val = IO () -> m ()
forall a. IO a -> m a
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.4/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:flags"
        })

argumentClass_flags :: AttrLabelProxy "flags"
argumentClass_flags = AttrLabelProxy

#endif


-- | Get the value of the “@priority@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentClass #priority
-- @
getArgumentClassPriority :: MonadIO m => ArgumentClass -> m Int32
getArgumentClassPriority :: forall (m :: * -> *). MonadIO m => ArgumentClass -> m Int32
getArgumentClassPriority ArgumentClass
s = IO Int32 -> m Int32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@priority@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentClass [ #priority 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentClassPriority :: MonadIO m => ArgumentClass -> Int32 -> m ()
setArgumentClassPriority :: forall (m :: * -> *). MonadIO m => ArgumentClass -> Int32 -> m ()
setArgumentClassPriority ArgumentClass
s Int32
val = IO () -> m ()
forall a. IO a -> m a
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.4/docs/GI-Vips-Structs-ArgumentClass.html#g:attr:priority"
        })

argumentClass_priority :: AttrLabelProxy "priority"
argumentClass_priority = AttrLabelProxy

#endif


-- | Get the value of the “@offset@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentClass #offset
-- @
getArgumentClassOffset :: MonadIO m => ArgumentClass -> m Word32
getArgumentClassOffset :: forall (m :: * -> *). MonadIO m => ArgumentClass -> m Word32
getArgumentClassOffset ArgumentClass
s = IO Word32 -> m Word32
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@offset@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentClass [ #offset 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentClassOffset :: MonadIO m => ArgumentClass -> Word32 -> m ()
setArgumentClassOffset :: forall (m :: * -> *). MonadIO m => ArgumentClass -> Word32 -> m ()
setArgumentClassOffset ArgumentClass
s Word32
val = IO () -> m ()
forall a. IO a -> m a
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.4/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, DK.Type)])
#endif

-- method ArgumentClass::needsstring
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "argument_class"
--           , argType =
--               TInterface Name { namespace = "Vips" , name = "ArgumentClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "vips_argument_class_needsstring" vips_argument_class_needsstring :: 
    Ptr ArgumentClass ->                    -- argument_class : TInterface (Name {namespace = "Vips", name = "ArgumentClass"})
    IO CInt

-- | /No description available in the introspection data./
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 a. IO a -> m a
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 a. a -> IO a
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.4/docs/GI-Vips-Structs-ArgumentClass.html#v:argumentClassNeedsstring"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveArgumentClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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