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

-- * Exported types
    SaveString(..)                          ,
    newZeroSaveString                       ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveSaveStringMethod                 ,
#endif



 -- * Properties


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

    clearSaveStringS                        ,
    getSaveStringS                          ,
#if defined(ENABLE_OVERLOADING)
    saveString_s                            ,
#endif
    setSaveStringS                          ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)

#else

#endif

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

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

foreign import ccall "vips_save_string_get_type" c_vips_save_string_get_type :: 
    IO GType

type instance O.ParentTypes SaveString = '[]
instance O.HasParentTypes SaveString

instance B.Types.TypedObject SaveString where
    glibType :: IO GType
glibType = IO GType
c_vips_save_string_get_type

instance B.Types.GBoxed SaveString

-- | Convert 'SaveString' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe SaveString) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_vips_save_string_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SaveString -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SaveString
P.Nothing = Ptr GValue -> Ptr SaveString -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr SaveString
forall a. Ptr a
FP.nullPtr :: FP.Ptr SaveString)
    gvalueSet_ Ptr GValue
gv (P.Just SaveString
obj) = SaveString -> (Ptr SaveString -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SaveString
obj (Ptr GValue -> Ptr SaveString -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SaveString)
gvalueGet_ Ptr GValue
gv = do
        Ptr SaveString
ptr <- Ptr GValue -> IO (Ptr SaveString)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr SaveString)
        if Ptr SaveString
ptr Ptr SaveString -> Ptr SaveString -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SaveString
forall a. Ptr a
FP.nullPtr
        then SaveString -> Maybe SaveString
forall a. a -> Maybe a
P.Just (SaveString -> Maybe SaveString)
-> IO SaveString -> IO (Maybe SaveString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SaveString -> SaveString)
-> Ptr SaveString -> IO SaveString
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr SaveString -> SaveString
SaveString Ptr SaveString
ptr
        else Maybe SaveString -> IO (Maybe SaveString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SaveString
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `SaveString` struct initialized to zero.
newZeroSaveString :: MonadIO m => m SaveString
newZeroSaveString :: forall (m :: * -> *). MonadIO m => m SaveString
newZeroSaveString = IO SaveString -> m SaveString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SaveString -> m SaveString) -> IO SaveString -> m SaveString
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr SaveString)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
8 IO (Ptr SaveString)
-> (Ptr SaveString -> IO SaveString) -> IO SaveString
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr SaveString -> SaveString)
-> Ptr SaveString -> IO SaveString
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SaveString -> SaveString
SaveString

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


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

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

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

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

saveString_s :: AttrLabelProxy "s"
saveString_s = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SaveString
type instance O.AttributeList SaveString = SaveStringAttributeList
type SaveStringAttributeList = ('[ '("s", SaveStringSFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

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

#endif

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

#endif