{-# 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.ArgumentInstance
    ( 

-- * Exported types
    ArgumentInstance(..)                    ,
    newZeroArgumentInstance                 ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveArgumentInstanceMethod           ,
#endif



 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    argumentInstance_argumentClass          ,
#endif
    clearArgumentInstanceArgumentClass      ,
    getArgumentInstanceArgumentClass        ,
    setArgumentInstanceArgumentClass        ,


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

#if defined(ENABLE_OVERLOADING)
    argumentInstance_assigned               ,
#endif
    getArgumentInstanceAssigned             ,
    setArgumentInstanceAssigned             ,


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

#if defined(ENABLE_OVERLOADING)
    argumentInstance_closeId                ,
#endif
    getArgumentInstanceCloseId              ,
    setArgumentInstanceCloseId              ,


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

#if defined(ENABLE_OVERLOADING)
    argumentInstance_invalidateId           ,
#endif
    getArgumentInstanceInvalidateId         ,
    setArgumentInstanceInvalidateId         ,


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

#if defined(ENABLE_OVERLOADING)
    argumentInstance_object                 ,
#endif
    clearArgumentInstanceObject             ,
    getArgumentInstanceObject               ,
    setArgumentInstanceObject               ,


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

#if defined(ENABLE_OVERLOADING)
    argumentInstance_parent                 ,
#endif
    getArgumentInstanceParent               ,




    ) 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.Objects.Object as Vips.Object
import {-# SOURCE #-} qualified GI.Vips.Structs.Argument as Vips.Argument
import {-# SOURCE #-} qualified GI.Vips.Structs.ArgumentClass as Vips.ArgumentClass

-- | Memory-managed wrapper type.
newtype ArgumentInstance = ArgumentInstance (SP.ManagedPtr ArgumentInstance)
    deriving (ArgumentInstance -> ArgumentInstance -> Bool
(ArgumentInstance -> ArgumentInstance -> Bool)
-> (ArgumentInstance -> ArgumentInstance -> Bool)
-> Eq ArgumentInstance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArgumentInstance -> ArgumentInstance -> Bool
== :: ArgumentInstance -> ArgumentInstance -> Bool
$c/= :: ArgumentInstance -> ArgumentInstance -> Bool
/= :: ArgumentInstance -> ArgumentInstance -> Bool
Eq)

instance SP.ManagedPtrNewtype ArgumentInstance where
    toManagedPtr :: ArgumentInstance -> ManagedPtr ArgumentInstance
toManagedPtr (ArgumentInstance ManagedPtr ArgumentInstance
p) = ManagedPtr ArgumentInstance
p

instance BoxedPtr ArgumentInstance where
    boxedPtrCopy :: ArgumentInstance -> IO ArgumentInstance
boxedPtrCopy = \ArgumentInstance
p -> ArgumentInstance
-> (Ptr ArgumentInstance -> IO ArgumentInstance)
-> IO ArgumentInstance
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ArgumentInstance
p (Int -> Ptr ArgumentInstance -> IO (Ptr ArgumentInstance)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
48 (Ptr ArgumentInstance -> IO (Ptr ArgumentInstance))
-> (Ptr ArgumentInstance -> IO ArgumentInstance)
-> Ptr ArgumentInstance
-> IO ArgumentInstance
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ArgumentInstance -> ArgumentInstance)
-> Ptr ArgumentInstance -> IO ArgumentInstance
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ArgumentInstance -> ArgumentInstance
ArgumentInstance)
    boxedPtrFree :: ArgumentInstance -> IO ()
boxedPtrFree = \ArgumentInstance
x -> ArgumentInstance -> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ArgumentInstance
x Ptr ArgumentInstance -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ArgumentInstance where
    boxedPtrCalloc :: IO (Ptr ArgumentInstance)
boxedPtrCalloc = Int -> IO (Ptr ArgumentInstance)
forall a. Int -> IO (Ptr a)
callocBytes Int
48


-- | Construct a `ArgumentInstance` struct initialized to zero.
newZeroArgumentInstance :: MonadIO m => m ArgumentInstance
newZeroArgumentInstance :: forall (m :: * -> *). MonadIO m => m ArgumentInstance
newZeroArgumentInstance = IO ArgumentInstance -> m ArgumentInstance
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ArgumentInstance -> m ArgumentInstance)
-> IO ArgumentInstance -> m ArgumentInstance
forall a b. (a -> b) -> a -> b
$ IO (Ptr ArgumentInstance)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ArgumentInstance)
-> (Ptr ArgumentInstance -> IO ArgumentInstance)
-> IO ArgumentInstance
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ArgumentInstance -> ArgumentInstance)
-> Ptr ArgumentInstance -> IO ArgumentInstance
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ArgumentInstance -> ArgumentInstance
ArgumentInstance

instance tag ~ 'AttrSet => Constructible ArgumentInstance tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ArgumentInstance -> ArgumentInstance)
-> [AttrOp ArgumentInstance tag] -> m ArgumentInstance
new ManagedPtr ArgumentInstance -> ArgumentInstance
_ [AttrOp ArgumentInstance tag]
attrs = do
        ArgumentInstance
o <- m ArgumentInstance
forall (m :: * -> *). MonadIO m => m ArgumentInstance
newZeroArgumentInstance
        ArgumentInstance -> [AttrOp ArgumentInstance 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ArgumentInstance
o [AttrOp ArgumentInstance tag]
[AttrOp ArgumentInstance 'AttrSet]
attrs
        ArgumentInstance -> m ArgumentInstance
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ArgumentInstance
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' argumentInstance #parent
-- @
getArgumentInstanceParent :: MonadIO m => ArgumentInstance -> m Vips.Argument.Argument
getArgumentInstanceParent :: forall (m :: * -> *). MonadIO m => ArgumentInstance -> m Argument
getArgumentInstanceParent ArgumentInstance
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
$ ArgumentInstance
-> (Ptr ArgumentInstance -> IO Argument) -> IO Argument
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO Argument) -> IO Argument)
-> (Ptr ArgumentInstance -> IO Argument) -> IO Argument
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    let val :: Ptr Argument
val = Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> 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 ArgumentInstanceParentFieldInfo
instance AttrInfo ArgumentInstanceParentFieldInfo where
    type AttrBaseTypeConstraint ArgumentInstanceParentFieldInfo = (~) ArgumentInstance
    type AttrAllowedOps ArgumentInstanceParentFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ArgumentInstanceParentFieldInfo = (~) (Ptr Vips.Argument.Argument)
    type AttrTransferTypeConstraint ArgumentInstanceParentFieldInfo = (~)(Ptr Vips.Argument.Argument)
    type AttrTransferType ArgumentInstanceParentFieldInfo = (Ptr Vips.Argument.Argument)
    type AttrGetType ArgumentInstanceParentFieldInfo = Vips.Argument.Argument
    type AttrLabel ArgumentInstanceParentFieldInfo = "parent"
    type AttrOrigin ArgumentInstanceParentFieldInfo = ArgumentInstance
    attrGet = getArgumentInstanceParent
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ArgumentInstance.parent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.4/docs/GI-Vips-Structs-ArgumentInstance.html#g:attr:parent"
        })

argumentInstance_parent :: AttrLabelProxy "parent"
argumentInstance_parent = AttrLabelProxy

#endif


-- | Get the value of the “@argument_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentInstance #argumentClass
-- @
getArgumentInstanceArgumentClass :: MonadIO m => ArgumentInstance -> m (Maybe Vips.ArgumentClass.ArgumentClass)
getArgumentInstanceArgumentClass :: forall (m :: * -> *).
MonadIO m =>
ArgumentInstance -> m (Maybe ArgumentClass)
getArgumentInstanceArgumentClass ArgumentInstance
s = IO (Maybe ArgumentClass) -> m (Maybe ArgumentClass)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ArgumentClass) -> m (Maybe ArgumentClass))
-> IO (Maybe ArgumentClass) -> m (Maybe ArgumentClass)
forall a b. (a -> b) -> a -> b
$ ArgumentInstance
-> (Ptr ArgumentInstance -> IO (Maybe ArgumentClass))
-> IO (Maybe ArgumentClass)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO (Maybe ArgumentClass))
 -> IO (Maybe ArgumentClass))
-> (Ptr ArgumentInstance -> IO (Maybe ArgumentClass))
-> IO (Maybe ArgumentClass)
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    Ptr ArgumentClass
val <- Ptr (Ptr ArgumentClass) -> IO (Ptr ArgumentClass)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr (Ptr ArgumentClass)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr Vips.ArgumentClass.ArgumentClass)
    Maybe ArgumentClass
result <- Ptr ArgumentClass
-> (Ptr ArgumentClass -> IO ArgumentClass)
-> IO (Maybe ArgumentClass)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr ArgumentClass
val ((Ptr ArgumentClass -> IO ArgumentClass)
 -> IO (Maybe ArgumentClass))
-> (Ptr ArgumentClass -> IO ArgumentClass)
-> IO (Maybe ArgumentClass)
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentClass
val' -> do
        ArgumentClass
val'' <- ((ManagedPtr ArgumentClass -> ArgumentClass)
-> Ptr ArgumentClass -> IO ArgumentClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ArgumentClass -> ArgumentClass
Vips.ArgumentClass.ArgumentClass) Ptr ArgumentClass
val'
        ArgumentClass -> IO ArgumentClass
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ArgumentClass
val''
    Maybe ArgumentClass -> IO (Maybe ArgumentClass)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ArgumentClass
result

-- | Set the value of the “@argument_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentInstance [ #argumentClass 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentInstanceArgumentClass :: MonadIO m => ArgumentInstance -> Ptr Vips.ArgumentClass.ArgumentClass -> m ()
setArgumentInstanceArgumentClass :: forall (m :: * -> *).
MonadIO m =>
ArgumentInstance -> Ptr ArgumentClass -> m ()
setArgumentInstanceArgumentClass ArgumentInstance
s Ptr ArgumentClass
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
$ ArgumentInstance -> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO ()) -> IO ())
-> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    Ptr (Ptr ArgumentClass) -> Ptr ArgumentClass -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr (Ptr ArgumentClass)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr ArgumentClass
val :: Ptr Vips.ArgumentClass.ArgumentClass)

-- | Set the value of the “@argument_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' #argumentClass
-- @
clearArgumentInstanceArgumentClass :: MonadIO m => ArgumentInstance -> m ()
clearArgumentInstanceArgumentClass :: forall (m :: * -> *). MonadIO m => ArgumentInstance -> m ()
clearArgumentInstanceArgumentClass ArgumentInstance
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
$ ArgumentInstance -> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO ()) -> IO ())
-> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    Ptr (Ptr ArgumentClass) -> Ptr ArgumentClass -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr (Ptr ArgumentClass)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr ArgumentClass
forall a. Ptr a
FP.nullPtr :: Ptr Vips.ArgumentClass.ArgumentClass)

#if defined(ENABLE_OVERLOADING)
data ArgumentInstanceArgumentClassFieldInfo
instance AttrInfo ArgumentInstanceArgumentClassFieldInfo where
    type AttrBaseTypeConstraint ArgumentInstanceArgumentClassFieldInfo = (~) ArgumentInstance
    type AttrAllowedOps ArgumentInstanceArgumentClassFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ArgumentInstanceArgumentClassFieldInfo = (~) (Ptr Vips.ArgumentClass.ArgumentClass)
    type AttrTransferTypeConstraint ArgumentInstanceArgumentClassFieldInfo = (~)(Ptr Vips.ArgumentClass.ArgumentClass)
    type AttrTransferType ArgumentInstanceArgumentClassFieldInfo = (Ptr Vips.ArgumentClass.ArgumentClass)
    type AttrGetType ArgumentInstanceArgumentClassFieldInfo = Maybe Vips.ArgumentClass.ArgumentClass
    type AttrLabel ArgumentInstanceArgumentClassFieldInfo = "argument_class"
    type AttrOrigin ArgumentInstanceArgumentClassFieldInfo = ArgumentInstance
    attrGet = getArgumentInstanceArgumentClass
    attrSet = setArgumentInstanceArgumentClass
    attrConstruct = undefined
    attrClear = clearArgumentInstanceArgumentClass
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ArgumentInstance.argumentClass"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.4/docs/GI-Vips-Structs-ArgumentInstance.html#g:attr:argumentClass"
        })

argumentInstance_argumentClass :: AttrLabelProxy "argumentClass"
argumentInstance_argumentClass = AttrLabelProxy

#endif


-- | Get the value of the “@object@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentInstance #object
-- @
getArgumentInstanceObject :: MonadIO m => ArgumentInstance -> m (Maybe Vips.Object.Object)
getArgumentInstanceObject :: forall (m :: * -> *).
MonadIO m =>
ArgumentInstance -> m (Maybe Object)
getArgumentInstanceObject ArgumentInstance
s = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ ArgumentInstance
-> (Ptr ArgumentInstance -> IO (Maybe Object)) -> IO (Maybe Object)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO (Maybe Object)) -> IO (Maybe Object))
-> (Ptr ArgumentInstance -> IO (Maybe Object)) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    Ptr Object
val <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr Vips.Object.Object)
    Maybe Object
result <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Object
val ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
val' -> do
        Object
val'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Vips.Object.Object) Ptr Object
val'
        Object -> IO Object
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Object
val''
    Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
result

-- | Set the value of the “@object@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentInstance [ #object 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentInstanceObject :: MonadIO m => ArgumentInstance -> Ptr Vips.Object.Object -> m ()
setArgumentInstanceObject :: forall (m :: * -> *).
MonadIO m =>
ArgumentInstance -> Ptr Object -> m ()
setArgumentInstanceObject ArgumentInstance
s Ptr Object
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
$ ArgumentInstance -> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO ()) -> IO ())
-> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    Ptr (Ptr Object) -> Ptr Object -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Object
val :: Ptr Vips.Object.Object)

-- | Set the value of the “@object@” 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' #object
-- @
clearArgumentInstanceObject :: MonadIO m => ArgumentInstance -> m ()
clearArgumentInstanceObject :: forall (m :: * -> *). MonadIO m => ArgumentInstance -> m ()
clearArgumentInstanceObject ArgumentInstance
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
$ ArgumentInstance -> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO ()) -> IO ())
-> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    Ptr (Ptr Object) -> Ptr Object -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Object
forall a. Ptr a
FP.nullPtr :: Ptr Vips.Object.Object)

#if defined(ENABLE_OVERLOADING)
data ArgumentInstanceObjectFieldInfo
instance AttrInfo ArgumentInstanceObjectFieldInfo where
    type AttrBaseTypeConstraint ArgumentInstanceObjectFieldInfo = (~) ArgumentInstance
    type AttrAllowedOps ArgumentInstanceObjectFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ArgumentInstanceObjectFieldInfo = (~) (Ptr Vips.Object.Object)
    type AttrTransferTypeConstraint ArgumentInstanceObjectFieldInfo = (~)(Ptr Vips.Object.Object)
    type AttrTransferType ArgumentInstanceObjectFieldInfo = (Ptr Vips.Object.Object)
    type AttrGetType ArgumentInstanceObjectFieldInfo = Maybe Vips.Object.Object
    type AttrLabel ArgumentInstanceObjectFieldInfo = "object"
    type AttrOrigin ArgumentInstanceObjectFieldInfo = ArgumentInstance
    attrGet = getArgumentInstanceObject
    attrSet = setArgumentInstanceObject
    attrConstruct = undefined
    attrClear = clearArgumentInstanceObject
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ArgumentInstance.object"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.4/docs/GI-Vips-Structs-ArgumentInstance.html#g:attr:object"
        })

argumentInstance_object :: AttrLabelProxy "object"
argumentInstance_object = AttrLabelProxy

#endif


-- | Get the value of the “@assigned@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentInstance #assigned
-- @
getArgumentInstanceAssigned :: MonadIO m => ArgumentInstance -> m Bool
getArgumentInstanceAssigned :: forall (m :: * -> *). MonadIO m => ArgumentInstance -> m Bool
getArgumentInstanceAssigned ArgumentInstance
s = 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
$ ArgumentInstance -> (Ptr ArgumentInstance -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO Bool) -> IO Bool)
-> (Ptr ArgumentInstance -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CInt
    let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'

-- | Set the value of the “@assigned@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentInstance [ #assigned 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentInstanceAssigned :: MonadIO m => ArgumentInstance -> Bool -> m ()
setArgumentInstanceAssigned :: forall (m :: * -> *). MonadIO m => ArgumentInstance -> Bool -> m ()
setArgumentInstanceAssigned ArgumentInstance
s Bool
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
$ ArgumentInstance -> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO ()) -> IO ())
-> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data ArgumentInstanceAssignedFieldInfo
instance AttrInfo ArgumentInstanceAssignedFieldInfo where
    type AttrBaseTypeConstraint ArgumentInstanceAssignedFieldInfo = (~) ArgumentInstance
    type AttrAllowedOps ArgumentInstanceAssignedFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentInstanceAssignedFieldInfo = (~) Bool
    type AttrTransferTypeConstraint ArgumentInstanceAssignedFieldInfo = (~)Bool
    type AttrTransferType ArgumentInstanceAssignedFieldInfo = Bool
    type AttrGetType ArgumentInstanceAssignedFieldInfo = Bool
    type AttrLabel ArgumentInstanceAssignedFieldInfo = "assigned"
    type AttrOrigin ArgumentInstanceAssignedFieldInfo = ArgumentInstance
    attrGet = getArgumentInstanceAssigned
    attrSet = setArgumentInstanceAssigned
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ArgumentInstance.assigned"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.4/docs/GI-Vips-Structs-ArgumentInstance.html#g:attr:assigned"
        })

argumentInstance_assigned :: AttrLabelProxy "assigned"
argumentInstance_assigned = AttrLabelProxy

#endif


-- | Get the value of the “@close_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentInstance #closeId
-- @
getArgumentInstanceCloseId :: MonadIO m => ArgumentInstance -> m CULong
getArgumentInstanceCloseId :: forall (m :: * -> *). MonadIO m => ArgumentInstance -> m CULong
getArgumentInstanceCloseId ArgumentInstance
s = IO CULong -> m CULong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ ArgumentInstance
-> (Ptr ArgumentInstance -> IO CULong) -> IO CULong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO CULong) -> IO CULong)
-> (Ptr ArgumentInstance -> IO CULong) -> IO CULong
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    CULong
val <- Ptr CULong -> IO CULong
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CULong
    CULong -> IO CULong
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val

-- | Set the value of the “@close_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentInstance [ #closeId 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentInstanceCloseId :: MonadIO m => ArgumentInstance -> CULong -> m ()
setArgumentInstanceCloseId :: forall (m :: * -> *).
MonadIO m =>
ArgumentInstance -> CULong -> m ()
setArgumentInstanceCloseId ArgumentInstance
s CULong
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
$ ArgumentInstance -> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO ()) -> IO ())
-> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    Ptr CULong -> CULong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CULong
val :: CULong)

#if defined(ENABLE_OVERLOADING)
data ArgumentInstanceCloseIdFieldInfo
instance AttrInfo ArgumentInstanceCloseIdFieldInfo where
    type AttrBaseTypeConstraint ArgumentInstanceCloseIdFieldInfo = (~) ArgumentInstance
    type AttrAllowedOps ArgumentInstanceCloseIdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentInstanceCloseIdFieldInfo = (~) CULong
    type AttrTransferTypeConstraint ArgumentInstanceCloseIdFieldInfo = (~)CULong
    type AttrTransferType ArgumentInstanceCloseIdFieldInfo = CULong
    type AttrGetType ArgumentInstanceCloseIdFieldInfo = CULong
    type AttrLabel ArgumentInstanceCloseIdFieldInfo = "close_id"
    type AttrOrigin ArgumentInstanceCloseIdFieldInfo = ArgumentInstance
    attrGet = getArgumentInstanceCloseId
    attrSet = setArgumentInstanceCloseId
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ArgumentInstance.closeId"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.4/docs/GI-Vips-Structs-ArgumentInstance.html#g:attr:closeId"
        })

argumentInstance_closeId :: AttrLabelProxy "closeId"
argumentInstance_closeId = AttrLabelProxy

#endif


-- | Get the value of the “@invalidate_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' argumentInstance #invalidateId
-- @
getArgumentInstanceInvalidateId :: MonadIO m => ArgumentInstance -> m CULong
getArgumentInstanceInvalidateId :: forall (m :: * -> *). MonadIO m => ArgumentInstance -> m CULong
getArgumentInstanceInvalidateId ArgumentInstance
s = IO CULong -> m CULong
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ ArgumentInstance
-> (Ptr ArgumentInstance -> IO CULong) -> IO CULong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO CULong) -> IO CULong)
-> (Ptr ArgumentInstance -> IO CULong) -> IO CULong
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    CULong
val <- Ptr CULong -> IO CULong
forall a. Storable a => Ptr a -> IO a
peek (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO CULong
    CULong -> IO CULong
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val

-- | Set the value of the “@invalidate_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' argumentInstance [ #invalidateId 'Data.GI.Base.Attributes.:=' value ]
-- @
setArgumentInstanceInvalidateId :: MonadIO m => ArgumentInstance -> CULong -> m ()
setArgumentInstanceInvalidateId :: forall (m :: * -> *).
MonadIO m =>
ArgumentInstance -> CULong -> m ()
setArgumentInstanceInvalidateId ArgumentInstance
s CULong
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
$ ArgumentInstance -> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ArgumentInstance
s ((Ptr ArgumentInstance -> IO ()) -> IO ())
-> (Ptr ArgumentInstance -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ArgumentInstance
ptr -> do
    Ptr CULong -> CULong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ArgumentInstance
ptr Ptr ArgumentInstance -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (CULong
val :: CULong)

#if defined(ENABLE_OVERLOADING)
data ArgumentInstanceInvalidateIdFieldInfo
instance AttrInfo ArgumentInstanceInvalidateIdFieldInfo where
    type AttrBaseTypeConstraint ArgumentInstanceInvalidateIdFieldInfo = (~) ArgumentInstance
    type AttrAllowedOps ArgumentInstanceInvalidateIdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ArgumentInstanceInvalidateIdFieldInfo = (~) CULong
    type AttrTransferTypeConstraint ArgumentInstanceInvalidateIdFieldInfo = (~)CULong
    type AttrTransferType ArgumentInstanceInvalidateIdFieldInfo = CULong
    type AttrGetType ArgumentInstanceInvalidateIdFieldInfo = CULong
    type AttrLabel ArgumentInstanceInvalidateIdFieldInfo = "invalidate_id"
    type AttrOrigin ArgumentInstanceInvalidateIdFieldInfo = ArgumentInstance
    attrGet = getArgumentInstanceInvalidateId
    attrSet = setArgumentInstanceInvalidateId
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ArgumentInstance.invalidateId"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.4/docs/GI-Vips-Structs-ArgumentInstance.html#g:attr:invalidateId"
        })

argumentInstance_invalidateId :: AttrLabelProxy "invalidateId"
argumentInstance_invalidateId = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ArgumentInstance
type instance O.AttributeList ArgumentInstance = ArgumentInstanceAttributeList
type ArgumentInstanceAttributeList = ('[ '("parent", ArgumentInstanceParentFieldInfo), '("argumentClass", ArgumentInstanceArgumentClassFieldInfo), '("object", ArgumentInstanceObjectFieldInfo), '("assigned", ArgumentInstanceAssignedFieldInfo), '("closeId", ArgumentInstanceCloseIdFieldInfo), '("invalidateId", ArgumentInstanceInvalidateIdFieldInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveArgumentInstanceMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveArgumentInstanceMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveArgumentInstanceMethod t ArgumentInstance, O.OverloadedMethod info ArgumentInstance p) => OL.IsLabel t (ArgumentInstance -> 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 ~ ResolveArgumentInstanceMethod t ArgumentInstance, O.OverloadedMethod info ArgumentInstance p, R.HasField t ArgumentInstance p) => R.HasField t ArgumentInstance p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveArgumentInstanceMethod t ArgumentInstance, O.OverloadedMethodInfo info ArgumentInstance) => OL.IsLabel t (O.MethodProxy info ArgumentInstance) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif