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

-- * Exported types
    ObjectClass(..)                         ,
    newZeroObjectClass                      ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveObjectClassMethod                ,
#endif

-- ** installArgument #method:installArgument#

#if defined(ENABLE_OVERLOADING)
    ObjectClassInstallArgumentMethodInfo    ,
#endif
    objectClassInstallArgument              ,




 -- * Properties


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

    clearObjectClassArgumentTable           ,
    getObjectClassArgumentTable             ,
#if defined(ENABLE_OVERLOADING)
    objectClass_argumentTable               ,
#endif
    setObjectClassArgumentTable             ,


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

    clearObjectClassArgumentTableTraverse   ,
    getObjectClassArgumentTableTraverse     ,
#if defined(ENABLE_OVERLOADING)
    objectClass_argumentTableTraverse       ,
#endif
    setObjectClassArgumentTableTraverse     ,


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

    getObjectClassArgumentTableTraverseGtype,
#if defined(ENABLE_OVERLOADING)
    objectClass_argumentTableTraverseGtype  ,
#endif
    setObjectClassArgumentTableTraverseGtype,


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

    clearObjectClassBuild                   ,
    getObjectClassBuild                     ,
#if defined(ENABLE_OVERLOADING)
    objectClass_build                       ,
#endif
    setObjectClassBuild                     ,


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

    clearObjectClassClose                   ,
    getObjectClassClose                     ,
#if defined(ENABLE_OVERLOADING)
    objectClass_close                       ,
#endif
    setObjectClassClose                     ,


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

    getObjectClassDeprecated                ,
#if defined(ENABLE_OVERLOADING)
    objectClass_deprecated                  ,
#endif
    setObjectClassDeprecated                ,


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

    clearObjectClassDescription             ,
    getObjectClassDescription               ,
#if defined(ENABLE_OVERLOADING)
    objectClass_description                 ,
#endif
    setObjectClassDescription               ,


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

    clearObjectClassNickname                ,
    getObjectClassNickname                  ,
#if defined(ENABLE_OVERLOADING)
    objectClass_nickname                    ,
#endif
    setObjectClassNickname                  ,


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

    getObjectClassOutputNeedsArg            ,
#if defined(ENABLE_OVERLOADING)
    objectClass_outputNeedsArg              ,
#endif
    setObjectClassOutputNeedsArg            ,


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

    clearObjectClassOutputToArg             ,
    getObjectClassOutputToArg               ,
#if defined(ENABLE_OVERLOADING)
    objectClass_outputToArg                 ,
#endif
    setObjectClassOutputToArg               ,


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

    getObjectClassParentClass               ,
#if defined(ENABLE_OVERLOADING)
    objectClass_parentClass                 ,
#endif


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

    clearObjectClassPostbuild               ,
    getObjectClassPostbuild                 ,
#if defined(ENABLE_OVERLOADING)
    objectClass_postbuild                   ,
#endif
    setObjectClassPostbuild                 ,


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

    clearObjectClassPostclose               ,
    getObjectClassPostclose                 ,
#if defined(ENABLE_OVERLOADING)
    objectClass_postclose                   ,
#endif
    setObjectClassPostclose                 ,


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

    clearObjectClassPreclose                ,
    getObjectClassPreclose                  ,
#if defined(ENABLE_OVERLOADING)
    objectClass_preclose                    ,
#endif
    setObjectClassPreclose                  ,


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

    clearObjectClassRewind                  ,
    getObjectClassRewind                    ,
#if defined(ENABLE_OVERLOADING)
    objectClass_rewind                      ,
#endif
    setObjectClassRewind                    ,




    ) 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 qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Vips.Callbacks as Vips.Callbacks
import {-# SOURCE #-} qualified GI.Vips.Flags as Vips.Flags

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

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

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


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

instance tag ~ 'AttrSet => Constructible ObjectClass tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ObjectClass -> ObjectClass)
-> [AttrOp ObjectClass tag] -> m ObjectClass
new ManagedPtr ObjectClass -> ObjectClass
_ [AttrOp ObjectClass tag]
attrs = do
        ObjectClass
o <- m ObjectClass
forall (m :: * -> *). MonadIO m => m ObjectClass
newZeroObjectClass
        ObjectClass -> [AttrOp ObjectClass 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ObjectClass
o [AttrOp ObjectClass tag]
[AttrOp ObjectClass 'AttrSet]
attrs
        ObjectClass -> m ObjectClass
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClass
o


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

#if defined(ENABLE_OVERLOADING)
data ObjectClassParentClassFieldInfo
instance AttrInfo ObjectClassParentClassFieldInfo where
    type AttrBaseTypeConstraint ObjectClassParentClassFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassParentClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ObjectClassParentClassFieldInfo = (~) (Ptr GObject.ObjectClass.ObjectClass)
    type AttrTransferTypeConstraint ObjectClassParentClassFieldInfo = (~)(Ptr GObject.ObjectClass.ObjectClass)
    type AttrTransferType ObjectClassParentClassFieldInfo = (Ptr GObject.ObjectClass.ObjectClass)
    type AttrGetType ObjectClassParentClassFieldInfo = GObject.ObjectClass.ObjectClass
    type AttrLabel ObjectClassParentClassFieldInfo = "parent_class"
    type AttrOrigin ObjectClassParentClassFieldInfo = ObjectClass
    attrGet = getObjectClassParentClass
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.parentClass"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:parentClass"
        })

objectClass_parentClass :: AttrLabelProxy "parentClass"
objectClass_parentClass = AttrLabelProxy

#endif


-- | Get the value of the “@build@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #build
-- @
getObjectClassBuild :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassBuildFieldCallback)
getObjectClassBuild :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassBuildFieldCallback)
getObjectClassBuild ObjectClass
s = IO (Maybe ObjectClassBuildFieldCallback)
-> m (Maybe ObjectClassBuildFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassBuildFieldCallback)
 -> m (Maybe ObjectClassBuildFieldCallback))
-> IO (Maybe ObjectClassBuildFieldCallback)
-> m (Maybe ObjectClassBuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassBuildFieldCallback))
-> IO (Maybe ObjectClassBuildFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassBuildFieldCallback))
 -> IO (Maybe ObjectClassBuildFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassBuildFieldCallback))
-> IO (Maybe ObjectClassBuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassBuildFieldCallback
val <- Ptr (FunPtr C_ObjectClassBuildFieldCallback)
-> IO (FunPtr C_ObjectClassBuildFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassBuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) :: IO (FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)
    Maybe ObjectClassBuildFieldCallback
result <- FunPtr C_ObjectClassBuildFieldCallback
-> (FunPtr C_ObjectClassBuildFieldCallback
    -> IO ObjectClassBuildFieldCallback)
-> IO (Maybe ObjectClassBuildFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassBuildFieldCallback
val ((FunPtr C_ObjectClassBuildFieldCallback
  -> IO ObjectClassBuildFieldCallback)
 -> IO (Maybe ObjectClassBuildFieldCallback))
-> (FunPtr C_ObjectClassBuildFieldCallback
    -> IO ObjectClassBuildFieldCallback)
-> IO (Maybe ObjectClassBuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassBuildFieldCallback
val' -> do
        let val'' :: ObjectClassBuildFieldCallback
val'' = FunPtr C_ObjectClassBuildFieldCallback
-> ObjectClassBuildFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassBuildFieldCallback -> a -> m Int32
Vips.Callbacks.dynamic_ObjectClassBuildFieldCallback FunPtr C_ObjectClassBuildFieldCallback
val'
        ObjectClassBuildFieldCallback -> IO ObjectClassBuildFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassBuildFieldCallback
val''
    Maybe ObjectClassBuildFieldCallback
-> IO (Maybe ObjectClassBuildFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassBuildFieldCallback
result

-- | Set the value of the “@build@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #build 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassBuild :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback -> m ()
setObjectClassBuild :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassBuildFieldCallback -> m ()
setObjectClassBuild ObjectClass
s FunPtr C_ObjectClassBuildFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassBuildFieldCallback)
-> FunPtr C_ObjectClassBuildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassBuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_ObjectClassBuildFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)

-- | Set the value of the “@build@” 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' #build
-- @
clearObjectClassBuild :: MonadIO m => ObjectClass -> m ()
clearObjectClassBuild :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassBuild ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassBuildFieldCallback)
-> FunPtr C_ObjectClassBuildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassBuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_ObjectClassBuildFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassBuildFieldInfo
instance AttrInfo ObjectClassBuildFieldInfo where
    type AttrBaseTypeConstraint ObjectClassBuildFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassBuildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassBuildFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)
    type AttrTransferTypeConstraint ObjectClassBuildFieldInfo = (~)Vips.Callbacks.ObjectClassBuildFieldCallback
    type AttrTransferType ObjectClassBuildFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassBuildFieldCallback)
    type AttrGetType ObjectClassBuildFieldInfo = Maybe Vips.Callbacks.ObjectClassBuildFieldCallback
    type AttrLabel ObjectClassBuildFieldInfo = "build"
    type AttrOrigin ObjectClassBuildFieldInfo = ObjectClass
    attrGet = getObjectClassBuild
    attrSet = setObjectClassBuild
    attrConstruct = undefined
    attrClear = clearObjectClassBuild
    attrTransfer _ v = do
        Vips.Callbacks.mk_ObjectClassBuildFieldCallback (Vips.Callbacks.wrap_ObjectClassBuildFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.build"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:build"
        })

objectClass_build :: AttrLabelProxy "build"
objectClass_build = AttrLabelProxy

#endif


-- | Get the value of the “@postbuild@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #postbuild
-- @
getObjectClassPostbuild :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassPostbuildFieldCallback)
getObjectClassPostbuild :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassPostbuildFieldCallback)
getObjectClassPostbuild ObjectClass
s = IO (Maybe ObjectClassPostbuildFieldCallback)
-> m (Maybe ObjectClassPostbuildFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassPostbuildFieldCallback)
 -> m (Maybe ObjectClassPostbuildFieldCallback))
-> IO (Maybe ObjectClassPostbuildFieldCallback)
-> m (Maybe ObjectClassPostbuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassPostbuildFieldCallback))
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassPostbuildFieldCallback))
 -> IO (Maybe ObjectClassPostbuildFieldCallback))
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassPostbuildFieldCallback))
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassPostbuildFieldCallback
val <- Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
-> IO (FunPtr C_ObjectClassPostbuildFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) :: IO (FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)
    Maybe ObjectClassPostbuildFieldCallback
result <- FunPtr C_ObjectClassPostbuildFieldCallback
-> (FunPtr C_ObjectClassPostbuildFieldCallback
    -> IO ObjectClassPostbuildFieldCallback)
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassPostbuildFieldCallback
val ((FunPtr C_ObjectClassPostbuildFieldCallback
  -> IO ObjectClassPostbuildFieldCallback)
 -> IO (Maybe ObjectClassPostbuildFieldCallback))
-> (FunPtr C_ObjectClassPostbuildFieldCallback
    -> IO ObjectClassPostbuildFieldCallback)
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassPostbuildFieldCallback
val' -> do
        let val'' :: ObjectClassPostbuildFieldCallback
val'' = FunPtr C_ObjectClassPostbuildFieldCallback
-> ObjectClassPostbuildFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassPostbuildFieldCallback
-> a -> Ptr () -> m Int32
Vips.Callbacks.dynamic_ObjectClassPostbuildFieldCallback FunPtr C_ObjectClassPostbuildFieldCallback
val'
        ObjectClassPostbuildFieldCallback
-> IO ObjectClassPostbuildFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassPostbuildFieldCallback
val''
    Maybe ObjectClassPostbuildFieldCallback
-> IO (Maybe ObjectClassPostbuildFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassPostbuildFieldCallback
result

-- | Set the value of the “@postbuild@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #postbuild 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassPostbuild :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback -> m ()
setObjectClassPostbuild :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassPostbuildFieldCallback -> m ()
setObjectClassPostbuild ObjectClass
s FunPtr C_ObjectClassPostbuildFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
-> FunPtr C_ObjectClassPostbuildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_ObjectClassPostbuildFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)

-- | Set the value of the “@postbuild@” 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' #postbuild
-- @
clearObjectClassPostbuild :: MonadIO m => ObjectClass -> m ()
clearObjectClassPostbuild :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassPostbuild ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
-> FunPtr C_ObjectClassPostbuildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassPostbuildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_ObjectClassPostbuildFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassPostbuildFieldInfo
instance AttrInfo ObjectClassPostbuildFieldInfo where
    type AttrBaseTypeConstraint ObjectClassPostbuildFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassPostbuildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassPostbuildFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)
    type AttrTransferTypeConstraint ObjectClassPostbuildFieldInfo = (~)Vips.Callbacks.ObjectClassPostbuildFieldCallback
    type AttrTransferType ObjectClassPostbuildFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassPostbuildFieldCallback)
    type AttrGetType ObjectClassPostbuildFieldInfo = Maybe Vips.Callbacks.ObjectClassPostbuildFieldCallback
    type AttrLabel ObjectClassPostbuildFieldInfo = "postbuild"
    type AttrOrigin ObjectClassPostbuildFieldInfo = ObjectClass
    attrGet = getObjectClassPostbuild
    attrSet = setObjectClassPostbuild
    attrConstruct = undefined
    attrClear = clearObjectClassPostbuild
    attrTransfer _ v = do
        Vips.Callbacks.mk_ObjectClassPostbuildFieldCallback (Vips.Callbacks.wrap_ObjectClassPostbuildFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.postbuild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:postbuild"
        })

objectClass_postbuild :: AttrLabelProxy "postbuild"
objectClass_postbuild = AttrLabelProxy

#endif


-- | Get the value of the “@rewind@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #rewind
-- @
getObjectClassRewind :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassRewindFieldCallback)
getObjectClassRewind :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassRewindFieldCallback)
getObjectClassRewind ObjectClass
s = IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassRewindFieldCallback)
 -> m (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
 -> IO (Maybe ObjectClassRewindFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassRewindFieldCallback
val <- Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> IO (FunPtr C_ObjectClassRewindFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) :: IO (FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)
    Maybe ObjectClassRewindFieldCallback
result <- FunPtr C_ObjectClassRewindFieldCallback
-> (FunPtr C_ObjectClassRewindFieldCallback
    -> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassRewindFieldCallback
val ((FunPtr C_ObjectClassRewindFieldCallback
  -> IO ObjectClassRewindFieldCallback)
 -> IO (Maybe ObjectClassRewindFieldCallback))
-> (FunPtr C_ObjectClassRewindFieldCallback
    -> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassRewindFieldCallback
val' -> do
        let val'' :: ObjectClassRewindFieldCallback
val'' = FunPtr C_ObjectClassRewindFieldCallback
-> ObjectClassRewindFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassRewindFieldCallback -> a -> m ()
Vips.Callbacks.dynamic_ObjectClassRewindFieldCallback FunPtr C_ObjectClassRewindFieldCallback
val'
        ObjectClassRewindFieldCallback -> IO ObjectClassRewindFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassRewindFieldCallback
val''
    Maybe ObjectClassRewindFieldCallback
-> IO (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassRewindFieldCallback
result

-- | Set the value of the “@rewind@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #rewind 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassRewind :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback -> m ()
setObjectClassRewind :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassRewindFieldCallback -> m ()
setObjectClassRewind ObjectClass
s FunPtr C_ObjectClassRewindFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_ObjectClassRewindFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)

-- | Set the value of the “@rewind@” 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' #rewind
-- @
clearObjectClassRewind :: MonadIO m => ObjectClass -> m ()
clearObjectClassRewind :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassRewind ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_ObjectClassRewindFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassRewindFieldInfo
instance AttrInfo ObjectClassRewindFieldInfo where
    type AttrBaseTypeConstraint ObjectClassRewindFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassRewindFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassRewindFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)
    type AttrTransferTypeConstraint ObjectClassRewindFieldInfo = (~)Vips.Callbacks.ObjectClassRewindFieldCallback
    type AttrTransferType ObjectClassRewindFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassRewindFieldCallback)
    type AttrGetType ObjectClassRewindFieldInfo = Maybe Vips.Callbacks.ObjectClassRewindFieldCallback
    type AttrLabel ObjectClassRewindFieldInfo = "rewind"
    type AttrOrigin ObjectClassRewindFieldInfo = ObjectClass
    attrGet = getObjectClassRewind
    attrSet = setObjectClassRewind
    attrConstruct = undefined
    attrClear = clearObjectClassRewind
    attrTransfer _ v = do
        Vips.Callbacks.mk_ObjectClassRewindFieldCallback (Vips.Callbacks.wrap_ObjectClassRewindFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.rewind"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:rewind"
        })

objectClass_rewind :: AttrLabelProxy "rewind"
objectClass_rewind = AttrLabelProxy

#endif


-- | Get the value of the “@preclose@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #preclose
-- @
getObjectClassPreclose :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassPrecloseFieldCallback)
getObjectClassPreclose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassRewindFieldCallback)
getObjectClassPreclose ObjectClass
s = IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassRewindFieldCallback)
 -> m (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
 -> IO (Maybe ObjectClassRewindFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassRewindFieldCallback
val <- Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> IO (FunPtr C_ObjectClassRewindFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) :: IO (FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)
    Maybe ObjectClassRewindFieldCallback
result <- FunPtr C_ObjectClassRewindFieldCallback
-> (FunPtr C_ObjectClassRewindFieldCallback
    -> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassRewindFieldCallback
val ((FunPtr C_ObjectClassRewindFieldCallback
  -> IO ObjectClassRewindFieldCallback)
 -> IO (Maybe ObjectClassRewindFieldCallback))
-> (FunPtr C_ObjectClassRewindFieldCallback
    -> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassRewindFieldCallback
val' -> do
        let val'' :: ObjectClassRewindFieldCallback
val'' = FunPtr C_ObjectClassRewindFieldCallback
-> ObjectClassRewindFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassRewindFieldCallback -> a -> m ()
Vips.Callbacks.dynamic_ObjectClassPrecloseFieldCallback FunPtr C_ObjectClassRewindFieldCallback
val'
        ObjectClassRewindFieldCallback -> IO ObjectClassRewindFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassRewindFieldCallback
val''
    Maybe ObjectClassRewindFieldCallback
-> IO (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassRewindFieldCallback
result

-- | Set the value of the “@preclose@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #preclose 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassPreclose :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback -> m ()
setObjectClassPreclose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassRewindFieldCallback -> m ()
setObjectClassPreclose ObjectClass
s FunPtr C_ObjectClassRewindFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_ObjectClassRewindFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)

-- | Set the value of the “@preclose@” 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' #preclose
-- @
clearObjectClassPreclose :: MonadIO m => ObjectClass -> m ()
clearObjectClassPreclose :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassPreclose ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_ObjectClassRewindFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassPrecloseFieldInfo
instance AttrInfo ObjectClassPrecloseFieldInfo where
    type AttrBaseTypeConstraint ObjectClassPrecloseFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassPrecloseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassPrecloseFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)
    type AttrTransferTypeConstraint ObjectClassPrecloseFieldInfo = (~)Vips.Callbacks.ObjectClassPrecloseFieldCallback
    type AttrTransferType ObjectClassPrecloseFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassPrecloseFieldCallback)
    type AttrGetType ObjectClassPrecloseFieldInfo = Maybe Vips.Callbacks.ObjectClassPrecloseFieldCallback
    type AttrLabel ObjectClassPrecloseFieldInfo = "preclose"
    type AttrOrigin ObjectClassPrecloseFieldInfo = ObjectClass
    attrGet = getObjectClassPreclose
    attrSet = setObjectClassPreclose
    attrConstruct = undefined
    attrClear = clearObjectClassPreclose
    attrTransfer _ v = do
        Vips.Callbacks.mk_ObjectClassPrecloseFieldCallback (Vips.Callbacks.wrap_ObjectClassPrecloseFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.preclose"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:preclose"
        })

objectClass_preclose :: AttrLabelProxy "preclose"
objectClass_preclose = AttrLabelProxy

#endif


-- | Get the value of the “@close@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #close
-- @
getObjectClassClose :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassCloseFieldCallback)
getObjectClassClose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassRewindFieldCallback)
getObjectClassClose ObjectClass
s = IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassRewindFieldCallback)
 -> m (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
 -> IO (Maybe ObjectClassRewindFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassRewindFieldCallback
val <- Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> IO (FunPtr C_ObjectClassRewindFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) :: IO (FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)
    Maybe ObjectClassRewindFieldCallback
result <- FunPtr C_ObjectClassRewindFieldCallback
-> (FunPtr C_ObjectClassRewindFieldCallback
    -> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassRewindFieldCallback
val ((FunPtr C_ObjectClassRewindFieldCallback
  -> IO ObjectClassRewindFieldCallback)
 -> IO (Maybe ObjectClassRewindFieldCallback))
-> (FunPtr C_ObjectClassRewindFieldCallback
    -> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassRewindFieldCallback
val' -> do
        let val'' :: ObjectClassRewindFieldCallback
val'' = FunPtr C_ObjectClassRewindFieldCallback
-> ObjectClassRewindFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassRewindFieldCallback -> a -> m ()
Vips.Callbacks.dynamic_ObjectClassCloseFieldCallback FunPtr C_ObjectClassRewindFieldCallback
val'
        ObjectClassRewindFieldCallback -> IO ObjectClassRewindFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassRewindFieldCallback
val''
    Maybe ObjectClassRewindFieldCallback
-> IO (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassRewindFieldCallback
result

-- | Set the value of the “@close@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #close 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassClose :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback -> m ()
setObjectClassClose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassRewindFieldCallback -> m ()
setObjectClassClose ObjectClass
s FunPtr C_ObjectClassRewindFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_ObjectClassRewindFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)

-- | Set the value of the “@close@” 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' #close
-- @
clearObjectClassClose :: MonadIO m => ObjectClass -> m ()
clearObjectClassClose :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassClose ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_ObjectClassRewindFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassCloseFieldInfo
instance AttrInfo ObjectClassCloseFieldInfo where
    type AttrBaseTypeConstraint ObjectClassCloseFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassCloseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassCloseFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)
    type AttrTransferTypeConstraint ObjectClassCloseFieldInfo = (~)Vips.Callbacks.ObjectClassCloseFieldCallback
    type AttrTransferType ObjectClassCloseFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassCloseFieldCallback)
    type AttrGetType ObjectClassCloseFieldInfo = Maybe Vips.Callbacks.ObjectClassCloseFieldCallback
    type AttrLabel ObjectClassCloseFieldInfo = "close"
    type AttrOrigin ObjectClassCloseFieldInfo = ObjectClass
    attrGet = getObjectClassClose
    attrSet = setObjectClassClose
    attrConstruct = undefined
    attrClear = clearObjectClassClose
    attrTransfer _ v = do
        Vips.Callbacks.mk_ObjectClassCloseFieldCallback (Vips.Callbacks.wrap_ObjectClassCloseFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.close"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:close"
        })

objectClass_close :: AttrLabelProxy "close"
objectClass_close = AttrLabelProxy

#endif


-- | Get the value of the “@postclose@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #postclose
-- @
getObjectClassPostclose :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassPostcloseFieldCallback)
getObjectClassPostclose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassRewindFieldCallback)
getObjectClassPostclose ObjectClass
s = IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassRewindFieldCallback)
 -> m (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
-> m (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
 -> IO (Maybe ObjectClassRewindFieldCallback))
-> (Ptr ObjectClass -> IO (Maybe ObjectClassRewindFieldCallback))
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassRewindFieldCallback
val <- Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> IO (FunPtr C_ObjectClassRewindFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) :: IO (FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)
    Maybe ObjectClassRewindFieldCallback
result <- FunPtr C_ObjectClassRewindFieldCallback
-> (FunPtr C_ObjectClassRewindFieldCallback
    -> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassRewindFieldCallback
val ((FunPtr C_ObjectClassRewindFieldCallback
  -> IO ObjectClassRewindFieldCallback)
 -> IO (Maybe ObjectClassRewindFieldCallback))
-> (FunPtr C_ObjectClassRewindFieldCallback
    -> IO ObjectClassRewindFieldCallback)
-> IO (Maybe ObjectClassRewindFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassRewindFieldCallback
val' -> do
        let val'' :: ObjectClassRewindFieldCallback
val'' = FunPtr C_ObjectClassRewindFieldCallback
-> ObjectClassRewindFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassRewindFieldCallback -> a -> m ()
Vips.Callbacks.dynamic_ObjectClassPostcloseFieldCallback FunPtr C_ObjectClassRewindFieldCallback
val'
        ObjectClassRewindFieldCallback -> IO ObjectClassRewindFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassRewindFieldCallback
val''
    Maybe ObjectClassRewindFieldCallback
-> IO (Maybe ObjectClassRewindFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassRewindFieldCallback
result

-- | Set the value of the “@postclose@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #postclose 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassPostclose :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback -> m ()
setObjectClassPostclose :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassRewindFieldCallback -> m ()
setObjectClassPostclose ObjectClass
s FunPtr C_ObjectClassRewindFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_ObjectClassRewindFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)

-- | Set the value of the “@postclose@” 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' #postclose
-- @
clearObjectClassPostclose :: MonadIO m => ObjectClass -> m ()
clearObjectClassPostclose :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassPostclose ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassRewindFieldCallback)
-> FunPtr C_ObjectClassRewindFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassRewindFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_ObjectClassRewindFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassPostcloseFieldInfo
instance AttrInfo ObjectClassPostcloseFieldInfo where
    type AttrBaseTypeConstraint ObjectClassPostcloseFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassPostcloseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassPostcloseFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)
    type AttrTransferTypeConstraint ObjectClassPostcloseFieldInfo = (~)Vips.Callbacks.ObjectClassPostcloseFieldCallback
    type AttrTransferType ObjectClassPostcloseFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassPostcloseFieldCallback)
    type AttrGetType ObjectClassPostcloseFieldInfo = Maybe Vips.Callbacks.ObjectClassPostcloseFieldCallback
    type AttrLabel ObjectClassPostcloseFieldInfo = "postclose"
    type AttrOrigin ObjectClassPostcloseFieldInfo = ObjectClass
    attrGet = getObjectClassPostclose
    attrSet = setObjectClassPostclose
    attrConstruct = undefined
    attrClear = clearObjectClassPostclose
    attrTransfer _ v = do
        Vips.Callbacks.mk_ObjectClassPostcloseFieldCallback (Vips.Callbacks.wrap_ObjectClassPostcloseFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.postclose"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:postclose"
        })

objectClass_postclose :: AttrLabelProxy "postclose"
objectClass_postclose = AttrLabelProxy

#endif


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

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

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

objectClass_outputNeedsArg :: AttrLabelProxy "outputNeedsArg"
objectClass_outputNeedsArg = AttrLabelProxy

#endif


-- | Get the value of the “@output_to_arg@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #outputToArg
-- @
getObjectClassOutputToArg :: MonadIO m => ObjectClass -> m (Maybe Vips.Callbacks.ObjectClassOutputToArgFieldCallback)
getObjectClassOutputToArg :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe ObjectClassOutputToArgFieldCallback)
getObjectClassOutputToArg ObjectClass
s = IO (Maybe ObjectClassOutputToArgFieldCallback)
-> m (Maybe ObjectClassOutputToArgFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ObjectClassOutputToArgFieldCallback)
 -> m (Maybe ObjectClassOutputToArgFieldCallback))
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
-> m (Maybe ObjectClassOutputToArgFieldCallback)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass
  -> IO (Maybe ObjectClassOutputToArgFieldCallback))
 -> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> (Ptr ObjectClass
    -> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    FunPtr C_ObjectClassOutputToArgFieldCallback
val <- Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
-> IO (FunPtr C_ObjectClassOutputToArgFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) :: IO (FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)
    Maybe ObjectClassOutputToArgFieldCallback
result <- FunPtr C_ObjectClassOutputToArgFieldCallback
-> (FunPtr C_ObjectClassOutputToArgFieldCallback
    -> IO ObjectClassOutputToArgFieldCallback)
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ObjectClassOutputToArgFieldCallback
val ((FunPtr C_ObjectClassOutputToArgFieldCallback
  -> IO ObjectClassOutputToArgFieldCallback)
 -> IO (Maybe ObjectClassOutputToArgFieldCallback))
-> (FunPtr C_ObjectClassOutputToArgFieldCallback
    -> IO ObjectClassOutputToArgFieldCallback)
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_ObjectClassOutputToArgFieldCallback
val' -> do
        let val'' :: ObjectClassOutputToArgFieldCallback
val'' = FunPtr C_ObjectClassOutputToArgFieldCallback
-> ObjectClassOutputToArgFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
FunPtr C_ObjectClassOutputToArgFieldCallback
-> a -> Text -> m Int32
Vips.Callbacks.dynamic_ObjectClassOutputToArgFieldCallback FunPtr C_ObjectClassOutputToArgFieldCallback
val'
        ObjectClassOutputToArgFieldCallback
-> IO ObjectClassOutputToArgFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClassOutputToArgFieldCallback
val''
    Maybe ObjectClassOutputToArgFieldCallback
-> IO (Maybe ObjectClassOutputToArgFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ObjectClassOutputToArgFieldCallback
result

-- | Set the value of the “@output_to_arg@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #outputToArg 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassOutputToArg :: MonadIO m => ObjectClass -> FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback -> m ()
setObjectClassOutputToArg :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> FunPtr C_ObjectClassOutputToArgFieldCallback -> m ()
setObjectClassOutputToArg ObjectClass
s FunPtr C_ObjectClassOutputToArgFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
-> FunPtr C_ObjectClassOutputToArgFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_ObjectClassOutputToArgFieldCallback
val :: FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)

-- | Set the value of the “@output_to_arg@” 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' #outputToArg
-- @
clearObjectClassOutputToArg :: MonadIO m => ObjectClass -> m ()
clearObjectClassOutputToArg :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassOutputToArg ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
-> FunPtr C_ObjectClassOutputToArgFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass
-> Int -> Ptr (FunPtr C_ObjectClassOutputToArgFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_ObjectClassOutputToArgFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ObjectClassOutputToArgFieldInfo
instance AttrInfo ObjectClassOutputToArgFieldInfo where
    type AttrBaseTypeConstraint ObjectClassOutputToArgFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassOutputToArgFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassOutputToArgFieldInfo = (~) (FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)
    type AttrTransferTypeConstraint ObjectClassOutputToArgFieldInfo = (~)Vips.Callbacks.ObjectClassOutputToArgFieldCallback
    type AttrTransferType ObjectClassOutputToArgFieldInfo = (FunPtr Vips.Callbacks.C_ObjectClassOutputToArgFieldCallback)
    type AttrGetType ObjectClassOutputToArgFieldInfo = Maybe Vips.Callbacks.ObjectClassOutputToArgFieldCallback
    type AttrLabel ObjectClassOutputToArgFieldInfo = "output_to_arg"
    type AttrOrigin ObjectClassOutputToArgFieldInfo = ObjectClass
    attrGet = getObjectClassOutputToArg
    attrSet = setObjectClassOutputToArg
    attrConstruct = undefined
    attrClear = clearObjectClassOutputToArg
    attrTransfer _ v = do
        Vips.Callbacks.mk_ObjectClassOutputToArgFieldCallback (Vips.Callbacks.wrap_ObjectClassOutputToArgFieldCallback Nothing v)
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.outputToArg"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:outputToArg"
        })

objectClass_outputToArg :: AttrLabelProxy "outputToArg"
objectClass_outputToArg = AttrLabelProxy

#endif


-- | Get the value of the “@nickname@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #nickname
-- @
getObjectClassNickname :: MonadIO m => ObjectClass -> m (Maybe T.Text)
getObjectClassNickname :: forall (m :: * -> *). MonadIO m => ObjectClass -> m (Maybe Text)
getObjectClassNickname ObjectClass
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

-- | Set the value of the “@nickname@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #nickname 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassNickname :: MonadIO m => ObjectClass -> CString -> m ()
setObjectClassNickname :: forall (m :: * -> *). MonadIO m => ObjectClass -> CString -> m ()
setObjectClassNickname ObjectClass
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (CString
val :: CString)

-- | Set the value of the “@nickname@” 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' #nickname
-- @
clearObjectClassNickname :: MonadIO m => ObjectClass -> m ()
clearObjectClassNickname :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassNickname ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data ObjectClassNicknameFieldInfo
instance AttrInfo ObjectClassNicknameFieldInfo where
    type AttrBaseTypeConstraint ObjectClassNicknameFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassNicknameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassNicknameFieldInfo = (~) CString
    type AttrTransferTypeConstraint ObjectClassNicknameFieldInfo = (~)CString
    type AttrTransferType ObjectClassNicknameFieldInfo = CString
    type AttrGetType ObjectClassNicknameFieldInfo = Maybe T.Text
    type AttrLabel ObjectClassNicknameFieldInfo = "nickname"
    type AttrOrigin ObjectClassNicknameFieldInfo = ObjectClass
    attrGet = getObjectClassNickname
    attrSet = setObjectClassNickname
    attrConstruct = undefined
    attrClear = clearObjectClassNickname
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.nickname"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:nickname"
        })

objectClass_nickname :: AttrLabelProxy "nickname"
objectClass_nickname = AttrLabelProxy

#endif


-- | Get the value of the “@description@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #description
-- @
getObjectClassDescription :: MonadIO m => ObjectClass -> m (Maybe T.Text)
getObjectClassDescription :: forall (m :: * -> *). MonadIO m => ObjectClass -> m (Maybe Text)
getObjectClassDescription ObjectClass
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ObjectClass -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

-- | Set the value of the “@description@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #description 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassDescription :: MonadIO m => ObjectClass -> CString -> m ()
setObjectClassDescription :: forall (m :: * -> *). MonadIO m => ObjectClass -> CString -> m ()
setObjectClassDescription ObjectClass
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (CString
val :: CString)

-- | Set the value of the “@description@” 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' #description
-- @
clearObjectClassDescription :: MonadIO m => ObjectClass -> m ()
clearObjectClassDescription :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassDescription ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data ObjectClassDescriptionFieldInfo
instance AttrInfo ObjectClassDescriptionFieldInfo where
    type AttrBaseTypeConstraint ObjectClassDescriptionFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassDescriptionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassDescriptionFieldInfo = (~) CString
    type AttrTransferTypeConstraint ObjectClassDescriptionFieldInfo = (~)CString
    type AttrTransferType ObjectClassDescriptionFieldInfo = CString
    type AttrGetType ObjectClassDescriptionFieldInfo = Maybe T.Text
    type AttrLabel ObjectClassDescriptionFieldInfo = "description"
    type AttrOrigin ObjectClassDescriptionFieldInfo = ObjectClass
    attrGet = getObjectClassDescription
    attrSet = setObjectClassDescription
    attrConstruct = undefined
    attrClear = clearObjectClassDescription
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.description"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:description"
        })

objectClass_description :: AttrLabelProxy "description"
objectClass_description = AttrLabelProxy

#endif


-- | Get the value of the “@argument_table@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #argumentTable
-- @
getObjectClassArgumentTable :: MonadIO m => ObjectClass -> m (Maybe (Map.Map (Ptr ()) (Ptr ())))
getObjectClassArgumentTable :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> m (Maybe (Map (Ptr ()) (Ptr ())))
getObjectClassArgumentTable ObjectClass
s = IO (Maybe (Map (Ptr ()) (Ptr ())))
-> m (Maybe (Map (Ptr ()) (Ptr ())))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Map (Ptr ()) (Ptr ())))
 -> m (Maybe (Map (Ptr ()) (Ptr ()))))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
-> m (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. (a -> b) -> a -> b
$ ObjectClass
-> (Ptr ObjectClass -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
 -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> (Ptr ObjectClass -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (GHashTable (Ptr ()) (Ptr ()))
val <- Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> IO (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) :: IO (Ptr (GHashTable (Ptr ()) (Ptr ())))
    Maybe (Map (Ptr ()) (Ptr ()))
result <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> (Ptr (GHashTable (Ptr ()) (Ptr ()))
    -> IO (Map (Ptr ()) (Ptr ())))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (GHashTable (Ptr ()) (Ptr ()))
val ((Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO (Map (Ptr ()) (Ptr ())))
 -> IO (Maybe (Map (Ptr ()) (Ptr ()))))
-> (Ptr (GHashTable (Ptr ()) (Ptr ()))
    -> IO (Map (Ptr ()) (Ptr ())))
-> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall a b. (a -> b) -> a -> b
$ \Ptr (GHashTable (Ptr ()) (Ptr ()))
val' -> do
        [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
val'' <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> IO [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
val'
        let val''' :: [(Ptr (), PtrWrapped (Ptr ()))]
val''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
-> [(Ptr (), PtrWrapped (Ptr ()))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
ptrUnpackPtr [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
val''
        let val'''' :: [(Ptr (), Ptr ())]
val'''' = (PtrWrapped (Ptr ()) -> Ptr ())
-> [(Ptr (), PtrWrapped (Ptr ()))] -> [(Ptr (), Ptr ())]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr ()) -> Ptr ()
forall a. PtrWrapped (Ptr a) -> Ptr a
ptrUnpackPtr [(Ptr (), PtrWrapped (Ptr ()))]
val'''
        let val''''' :: Map (Ptr ()) (Ptr ())
val''''' = [(Ptr (), Ptr ())] -> Map (Ptr ()) (Ptr ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Ptr (), Ptr ())]
val''''
        Map (Ptr ()) (Ptr ()) -> IO (Map (Ptr ()) (Ptr ()))
forall (m :: * -> *) a. Monad m => a -> m a
return Map (Ptr ()) (Ptr ())
val'''''
    Maybe (Map (Ptr ()) (Ptr ())) -> IO (Maybe (Map (Ptr ()) (Ptr ())))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Map (Ptr ()) (Ptr ()))
result

-- | Set the value of the “@argument_table@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #argumentTable 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassArgumentTable :: MonadIO m => ObjectClass -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> m ()
setObjectClassArgumentTable :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> m ()
setObjectClassArgumentTable ObjectClass
s Ptr (GHashTable (Ptr ()) (Ptr ()))
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (Ptr (GHashTable (Ptr ()) (Ptr ()))
val :: Ptr (GHashTable (Ptr ()) (Ptr ())))

-- | Set the value of the “@argument_table@” 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' #argumentTable
-- @
clearObjectClassArgumentTable :: MonadIO m => ObjectClass -> m ()
clearObjectClassArgumentTable :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassArgumentTable ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
-> Ptr (GHashTable (Ptr ()) (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GHashTable (Ptr ()) (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (Ptr (GHashTable (Ptr ()) (Ptr ()))
forall a. Ptr a
FP.nullPtr :: Ptr (GHashTable (Ptr ()) (Ptr ())))

#if defined(ENABLE_OVERLOADING)
data ObjectClassArgumentTableFieldInfo
instance AttrInfo ObjectClassArgumentTableFieldInfo where
    type AttrBaseTypeConstraint ObjectClassArgumentTableFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassArgumentTableFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassArgumentTableFieldInfo = (~) (Ptr (GHashTable (Ptr ()) (Ptr ())))
    type AttrTransferTypeConstraint ObjectClassArgumentTableFieldInfo = (~)(Ptr (GHashTable (Ptr ()) (Ptr ())))
    type AttrTransferType ObjectClassArgumentTableFieldInfo = (Ptr (GHashTable (Ptr ()) (Ptr ())))
    type AttrGetType ObjectClassArgumentTableFieldInfo = Maybe (Map.Map (Ptr ()) (Ptr ()))
    type AttrLabel ObjectClassArgumentTableFieldInfo = "argument_table"
    type AttrOrigin ObjectClassArgumentTableFieldInfo = ObjectClass
    attrGet = getObjectClassArgumentTable
    attrSet = setObjectClassArgumentTable
    attrConstruct = undefined
    attrClear = clearObjectClassArgumentTable
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.argumentTable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:argumentTable"
        })

objectClass_argumentTable :: AttrLabelProxy "argumentTable"
objectClass_argumentTable = AttrLabelProxy

#endif


-- | Get the value of the “@argument_table_traverse@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' objectClass #argumentTableTraverse
-- @
getObjectClassArgumentTableTraverse :: MonadIO m => ObjectClass -> m ([Ptr ()])
getObjectClassArgumentTableTraverse :: forall (m :: * -> *). MonadIO m => ObjectClass -> m [Ptr ()]
getObjectClassArgumentTableTraverse ObjectClass
s = IO [Ptr ()] -> m [Ptr ()]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Ptr ()] -> m [Ptr ()]) -> IO [Ptr ()] -> m [Ptr ()]
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO [Ptr ()]) -> IO [Ptr ()]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO [Ptr ()]) -> IO [Ptr ()])
-> (Ptr ObjectClass -> IO [Ptr ()]) -> IO [Ptr ()]
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (GSList (Ptr ()))
val <- Ptr (Ptr (GSList (Ptr ()))) -> IO (Ptr (GSList (Ptr ())))
forall a. Storable a => Ptr a -> IO a
peek (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GSList (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) :: IO (Ptr (GSList (Ptr ())))
    [Ptr ()]
val' <- Ptr (GSList (Ptr ())) -> IO [Ptr ()]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr ()))
val
    [Ptr ()] -> IO [Ptr ()]
forall (m :: * -> *) a. Monad m => a -> m a
return [Ptr ()]
val'

-- | Set the value of the “@argument_table_traverse@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #argumentTableTraverse 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassArgumentTableTraverse :: MonadIO m => ObjectClass -> Ptr (GSList (Ptr ())) -> m ()
setObjectClassArgumentTableTraverse :: forall (m :: * -> *).
MonadIO m =>
ObjectClass -> Ptr (GSList (Ptr ())) -> m ()
setObjectClassArgumentTableTraverse ObjectClass
s Ptr (GSList (Ptr ()))
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (Ptr (GSList (Ptr ()))) -> Ptr (GSList (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GSList (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (Ptr (GSList (Ptr ()))
val :: Ptr (GSList (Ptr ())))

-- | Set the value of the “@argument_table_traverse@” 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' #argumentTableTraverse
-- @
clearObjectClassArgumentTableTraverse :: MonadIO m => ObjectClass -> m ()
clearObjectClassArgumentTableTraverse :: forall (m :: * -> *). MonadIO m => ObjectClass -> m ()
clearObjectClassArgumentTableTraverse ObjectClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    Ptr (Ptr (GSList (Ptr ()))) -> Ptr (GSList (Ptr ())) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr (Ptr (GSList (Ptr ())))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (Ptr (GSList (Ptr ()))
forall a. Ptr a
FP.nullPtr :: Ptr (GSList (Ptr ())))

#if defined(ENABLE_OVERLOADING)
data ObjectClassArgumentTableTraverseFieldInfo
instance AttrInfo ObjectClassArgumentTableTraverseFieldInfo where
    type AttrBaseTypeConstraint ObjectClassArgumentTableTraverseFieldInfo = (~) ObjectClass
    type AttrAllowedOps ObjectClassArgumentTableTraverseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectClassArgumentTableTraverseFieldInfo = (~) (Ptr (GSList (Ptr ())))
    type AttrTransferTypeConstraint ObjectClassArgumentTableTraverseFieldInfo = (~)(Ptr (GSList (Ptr ())))
    type AttrTransferType ObjectClassArgumentTableTraverseFieldInfo = (Ptr (GSList (Ptr ())))
    type AttrGetType ObjectClassArgumentTableTraverseFieldInfo = [Ptr ()]
    type AttrLabel ObjectClassArgumentTableTraverseFieldInfo = "argument_table_traverse"
    type AttrOrigin ObjectClassArgumentTableTraverseFieldInfo = ObjectClass
    attrGet = getObjectClassArgumentTableTraverse
    attrSet = setObjectClassArgumentTableTraverse
    attrConstruct = undefined
    attrClear = clearObjectClassArgumentTableTraverse
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.argumentTableTraverse"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#g:attr:argumentTableTraverse"
        })

objectClass_argumentTableTraverse :: AttrLabelProxy "argumentTableTraverse"
objectClass_argumentTableTraverse = AttrLabelProxy

#endif


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

-- | Set the value of the “@argument_table_traverse_gtype@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' objectClass [ #argumentTableTraverseGtype 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectClassArgumentTableTraverseGtype :: MonadIO m => ObjectClass -> GType -> m ()
setObjectClassArgumentTableTraverseGtype :: forall (m :: * -> *). MonadIO m => ObjectClass -> GType -> m ()
setObjectClassArgumentTableTraverseGtype ObjectClass
s GType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ObjectClass -> (Ptr ObjectClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ObjectClass
s ((Ptr ObjectClass -> IO ()) -> IO ())
-> (Ptr ObjectClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ObjectClass
ptr -> do
    let val' :: CGType
val' = GType -> CGType
gtypeToCGType GType
val
    Ptr CGType -> CGType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ObjectClass
ptr Ptr ObjectClass -> Int -> Ptr CGType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (CGType
val' :: CGType)

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

objectClass_argumentTableTraverseGtype :: AttrLabelProxy "argumentTableTraverseGtype"
objectClass_argumentTableTraverseGtype = AttrLabelProxy

#endif


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

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

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

objectClass_deprecated :: AttrLabelProxy "deprecated"
objectClass_deprecated = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ObjectClass
type instance O.AttributeList ObjectClass = ObjectClassAttributeList
type ObjectClassAttributeList = ('[ '("parentClass", ObjectClassParentClassFieldInfo), '("build", ObjectClassBuildFieldInfo), '("postbuild", ObjectClassPostbuildFieldInfo), '("rewind", ObjectClassRewindFieldInfo), '("preclose", ObjectClassPrecloseFieldInfo), '("close", ObjectClassCloseFieldInfo), '("postclose", ObjectClassPostcloseFieldInfo), '("outputNeedsArg", ObjectClassOutputNeedsArgFieldInfo), '("outputToArg", ObjectClassOutputToArgFieldInfo), '("nickname", ObjectClassNicknameFieldInfo), '("description", ObjectClassDescriptionFieldInfo), '("argumentTable", ObjectClassArgumentTableFieldInfo), '("argumentTableTraverse", ObjectClassArgumentTableTraverseFieldInfo), '("argumentTableTraverseGtype", ObjectClassArgumentTableTraverseGtypeFieldInfo), '("deprecated", ObjectClassDeprecatedFieldInfo)] :: [(Symbol, *)])
#endif

-- method ObjectClass::install_argument
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "cls"
--           , argType =
--               TInterface Name { namespace = "Vips" , name = "ObjectClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Vips" , name = "ArgumentFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "offset"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vips_object_class_install_argument" vips_object_class_install_argument :: 
    Ptr ObjectClass ->                      -- cls : TInterface (Name {namespace = "Vips", name = "ObjectClass"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    CUInt ->                                -- flags : TInterface (Name {namespace = "Vips", name = "ArgumentFlags"})
    Int32 ->                                -- priority : TBasicType TInt
    Word32 ->                               -- offset : TBasicType TUInt
    IO ()

-- | /No description available in the introspection data./
objectClassInstallArgument ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ObjectClass
    -> GParamSpec
    -> [Vips.Flags.ArgumentFlags]
    -> Int32
    -> Word32
    -> m ()
objectClassInstallArgument :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ObjectClass
-> GParamSpec -> [ArgumentFlags] -> Int32 -> Word32 -> m ()
objectClassInstallArgument ObjectClass
cls GParamSpec
pspec [ArgumentFlags]
flags Int32
priority Word32
offset = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ObjectClass
cls' <- ObjectClass -> IO (Ptr ObjectClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ObjectClass
cls
    Ptr GParamSpec
pspec' <- GParamSpec -> IO (Ptr GParamSpec)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    let flags' :: CUInt
flags' = [ArgumentFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ArgumentFlags]
flags
    Ptr ObjectClass
-> Ptr GParamSpec -> CUInt -> Int32 -> Word32 -> IO ()
vips_object_class_install_argument Ptr ObjectClass
cls' Ptr GParamSpec
pspec' CUInt
flags' Int32
priority Word32
offset
    ObjectClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ObjectClass
cls
    GParamSpec -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ObjectClassInstallArgumentMethodInfo
instance (signature ~ (GParamSpec -> [Vips.Flags.ArgumentFlags] -> Int32 -> Word32 -> m ()), MonadIO m) => O.OverloadedMethod ObjectClassInstallArgumentMethodInfo ObjectClass signature where
    overloadedMethod = objectClassInstallArgument

instance O.OverloadedMethodInfo ObjectClassInstallArgumentMethodInfo ObjectClass where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Structs.ObjectClass.objectClassInstallArgument",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Structs-ObjectClass.html#v:objectClassInstallArgument"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveObjectClassMethod (t :: Symbol) (o :: *) :: * where
    ResolveObjectClassMethod "installArgument" o = ObjectClassInstallArgumentMethodInfo
    ResolveObjectClassMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif