{-# 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.Dazzle.Structs.FuzzyMutableIndexMatch
    ( 

-- * Exported types
    FuzzyMutableIndexMatch(..)              ,
    newZeroFuzzyMutableIndexMatch           ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveFuzzyMutableIndexMatchMethod     ,
#endif



 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    fuzzyMutableIndexMatch_id               ,
#endif
    getFuzzyMutableIndexMatchId             ,
    setFuzzyMutableIndexMatchId             ,


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

    clearFuzzyMutableIndexMatchKey          ,
#if defined(ENABLE_OVERLOADING)
    fuzzyMutableIndexMatch_key              ,
#endif
    getFuzzyMutableIndexMatchKey            ,
    setFuzzyMutableIndexMatchKey            ,


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

#if defined(ENABLE_OVERLOADING)
    fuzzyMutableIndexMatch_score            ,
#endif
    getFuzzyMutableIndexMatchScore          ,
    setFuzzyMutableIndexMatchScore          ,


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

    clearFuzzyMutableIndexMatchValue        ,
#if defined(ENABLE_OVERLOADING)
    fuzzyMutableIndexMatch_value            ,
#endif
    getFuzzyMutableIndexMatchValue          ,
    setFuzzyMutableIndexMatchValue          ,




    ) 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 FuzzyMutableIndexMatch = FuzzyMutableIndexMatch (SP.ManagedPtr FuzzyMutableIndexMatch)
    deriving (FuzzyMutableIndexMatch -> FuzzyMutableIndexMatch -> Bool
(FuzzyMutableIndexMatch -> FuzzyMutableIndexMatch -> Bool)
-> (FuzzyMutableIndexMatch -> FuzzyMutableIndexMatch -> Bool)
-> Eq FuzzyMutableIndexMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuzzyMutableIndexMatch -> FuzzyMutableIndexMatch -> Bool
== :: FuzzyMutableIndexMatch -> FuzzyMutableIndexMatch -> Bool
$c/= :: FuzzyMutableIndexMatch -> FuzzyMutableIndexMatch -> Bool
/= :: FuzzyMutableIndexMatch -> FuzzyMutableIndexMatch -> Bool
Eq)

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

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


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

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


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

-- | Set the value of the “@key@” 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' #key
-- @
clearFuzzyMutableIndexMatchKey :: MonadIO m => FuzzyMutableIndexMatch -> m ()
clearFuzzyMutableIndexMatchKey :: forall (m :: * -> *). MonadIO m => FuzzyMutableIndexMatch -> m ()
clearFuzzyMutableIndexMatchKey FuzzyMutableIndexMatch
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
$ FuzzyMutableIndexMatch
-> (Ptr FuzzyMutableIndexMatch -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FuzzyMutableIndexMatch
s ((Ptr FuzzyMutableIndexMatch -> IO ()) -> IO ())
-> (Ptr FuzzyMutableIndexMatch -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FuzzyMutableIndexMatch
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FuzzyMutableIndexMatch
ptr Ptr FuzzyMutableIndexMatch -> 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 FuzzyMutableIndexMatchKeyFieldInfo
instance AttrInfo FuzzyMutableIndexMatchKeyFieldInfo where
    type AttrBaseTypeConstraint FuzzyMutableIndexMatchKeyFieldInfo = (~) FuzzyMutableIndexMatch
    type AttrAllowedOps FuzzyMutableIndexMatchKeyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FuzzyMutableIndexMatchKeyFieldInfo = (~) CString
    type AttrTransferTypeConstraint FuzzyMutableIndexMatchKeyFieldInfo = (~)CString
    type AttrTransferType FuzzyMutableIndexMatchKeyFieldInfo = CString
    type AttrGetType FuzzyMutableIndexMatchKeyFieldInfo = Maybe T.Text
    type AttrLabel FuzzyMutableIndexMatchKeyFieldInfo = "key"
    type AttrOrigin FuzzyMutableIndexMatchKeyFieldInfo = FuzzyMutableIndexMatch
    attrGet = getFuzzyMutableIndexMatchKey
    attrSet = setFuzzyMutableIndexMatchKey
    attrConstruct = undefined
    attrClear = clearFuzzyMutableIndexMatchKey
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.FuzzyMutableIndexMatch.key"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-FuzzyMutableIndexMatch.html#g:attr:key"
        })

fuzzyMutableIndexMatch_key :: AttrLabelProxy "key"
fuzzyMutableIndexMatch_key = AttrLabelProxy

#endif


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

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

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

#if defined(ENABLE_OVERLOADING)
data FuzzyMutableIndexMatchValueFieldInfo
instance AttrInfo FuzzyMutableIndexMatchValueFieldInfo where
    type AttrBaseTypeConstraint FuzzyMutableIndexMatchValueFieldInfo = (~) FuzzyMutableIndexMatch
    type AttrAllowedOps FuzzyMutableIndexMatchValueFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FuzzyMutableIndexMatchValueFieldInfo = (~) (Ptr ())
    type AttrTransferTypeConstraint FuzzyMutableIndexMatchValueFieldInfo = (~)(Ptr ())
    type AttrTransferType FuzzyMutableIndexMatchValueFieldInfo = (Ptr ())
    type AttrGetType FuzzyMutableIndexMatchValueFieldInfo = Ptr ()
    type AttrLabel FuzzyMutableIndexMatchValueFieldInfo = "value"
    type AttrOrigin FuzzyMutableIndexMatchValueFieldInfo = FuzzyMutableIndexMatch
    attrGet = getFuzzyMutableIndexMatchValue
    attrSet = setFuzzyMutableIndexMatchValue
    attrConstruct = undefined
    attrClear = clearFuzzyMutableIndexMatchValue
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.FuzzyMutableIndexMatch.value"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-FuzzyMutableIndexMatch.html#g:attr:value"
        })

fuzzyMutableIndexMatch_value :: AttrLabelProxy "value"
fuzzyMutableIndexMatch_value = AttrLabelProxy

#endif


-- | Get the value of the “@score@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fuzzyMutableIndexMatch #score
-- @
getFuzzyMutableIndexMatchScore :: MonadIO m => FuzzyMutableIndexMatch -> m Float
getFuzzyMutableIndexMatchScore :: forall (m :: * -> *).
MonadIO m =>
FuzzyMutableIndexMatch -> m Float
getFuzzyMutableIndexMatchScore FuzzyMutableIndexMatch
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ FuzzyMutableIndexMatch
-> (Ptr FuzzyMutableIndexMatch -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FuzzyMutableIndexMatch
s ((Ptr FuzzyMutableIndexMatch -> IO Float) -> IO Float)
-> (Ptr FuzzyMutableIndexMatch -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr FuzzyMutableIndexMatch
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr FuzzyMutableIndexMatch
ptr Ptr FuzzyMutableIndexMatch -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

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

#if defined(ENABLE_OVERLOADING)
data FuzzyMutableIndexMatchScoreFieldInfo
instance AttrInfo FuzzyMutableIndexMatchScoreFieldInfo where
    type AttrBaseTypeConstraint FuzzyMutableIndexMatchScoreFieldInfo = (~) FuzzyMutableIndexMatch
    type AttrAllowedOps FuzzyMutableIndexMatchScoreFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FuzzyMutableIndexMatchScoreFieldInfo = (~) Float
    type AttrTransferTypeConstraint FuzzyMutableIndexMatchScoreFieldInfo = (~)Float
    type AttrTransferType FuzzyMutableIndexMatchScoreFieldInfo = Float
    type AttrGetType FuzzyMutableIndexMatchScoreFieldInfo = Float
    type AttrLabel FuzzyMutableIndexMatchScoreFieldInfo = "score"
    type AttrOrigin FuzzyMutableIndexMatchScoreFieldInfo = FuzzyMutableIndexMatch
    attrGet = getFuzzyMutableIndexMatchScore
    attrSet = setFuzzyMutableIndexMatchScore
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.FuzzyMutableIndexMatch.score"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-FuzzyMutableIndexMatch.html#g:attr:score"
        })

fuzzyMutableIndexMatch_score :: AttrLabelProxy "score"
fuzzyMutableIndexMatch_score = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data FuzzyMutableIndexMatchIdFieldInfo
instance AttrInfo FuzzyMutableIndexMatchIdFieldInfo where
    type AttrBaseTypeConstraint FuzzyMutableIndexMatchIdFieldInfo = (~) FuzzyMutableIndexMatch
    type AttrAllowedOps FuzzyMutableIndexMatchIdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FuzzyMutableIndexMatchIdFieldInfo = (~) Word32
    type AttrTransferTypeConstraint FuzzyMutableIndexMatchIdFieldInfo = (~)Word32
    type AttrTransferType FuzzyMutableIndexMatchIdFieldInfo = Word32
    type AttrGetType FuzzyMutableIndexMatchIdFieldInfo = Word32
    type AttrLabel FuzzyMutableIndexMatchIdFieldInfo = "id"
    type AttrOrigin FuzzyMutableIndexMatchIdFieldInfo = FuzzyMutableIndexMatch
    attrGet = getFuzzyMutableIndexMatchId
    attrSet = setFuzzyMutableIndexMatchId
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Structs.FuzzyMutableIndexMatch.id"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Structs-FuzzyMutableIndexMatch.html#g:attr:id"
        })

fuzzyMutableIndexMatch_id :: AttrLabelProxy "id"
fuzzyMutableIndexMatch_id = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FuzzyMutableIndexMatch
type instance O.AttributeList FuzzyMutableIndexMatch = FuzzyMutableIndexMatchAttributeList
type FuzzyMutableIndexMatchAttributeList = ('[ '("key", FuzzyMutableIndexMatchKeyFieldInfo), '("value", FuzzyMutableIndexMatchValueFieldInfo), '("score", FuzzyMutableIndexMatchScoreFieldInfo), '("id", FuzzyMutableIndexMatchIdFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

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

#endif

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

#endif