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

-- * Exported types
    Argument(..)                            ,
    newZeroArgument                         ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveArgumentMethod                   ,
#endif



 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    argument_pspec                          ,
#endif
    clearArgumentPspec                      ,
    getArgumentPspec                        ,
    setArgumentPspec                        ,




    ) 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


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

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

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


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

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


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

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

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

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

argument_pspec :: AttrLabelProxy "pspec"
argument_pspec = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Argument
type instance O.AttributeList Argument = ArgumentAttributeList
type ArgumentAttributeList = ('[ '("pspec", ArgumentPspecFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveArgumentMethod (t :: Symbol) (o :: *) :: * where
    ResolveArgumentMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif