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

-- * Exported types
    FuzzyIndexBuilder(..)                   ,
    IsFuzzyIndexBuilder                     ,
    toFuzzyIndexBuilder                     ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [insert]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:insert"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"), [write]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:write"), [writeAsync]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:writeAsync"), [writeFinish]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:writeFinish").
-- 
-- ==== Getters
-- [getCaseSensitive]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:getCaseSensitive"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDocument]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:getDocument"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setCaseSensitive]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:setCaseSensitive"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setMetadata]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:setMetadata"), [setMetadataString]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:setMetadataString"), [setMetadataUint32]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:setMetadataUint32"), [setMetadataUint64]("GI.Dazzle.Objects.FuzzyIndexBuilder#g:method:setMetadataUint64"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveFuzzyIndexBuilderMethod          ,
#endif

-- ** getCaseSensitive #method:getCaseSensitive#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderGetCaseSensitiveMethodInfo,
#endif
    fuzzyIndexBuilderGetCaseSensitive       ,


-- ** getDocument #method:getDocument#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderGetDocumentMethodInfo  ,
#endif
    fuzzyIndexBuilderGetDocument            ,


-- ** insert #method:insert#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderInsertMethodInfo       ,
#endif
    fuzzyIndexBuilderInsert                 ,


-- ** new #method:new#

    fuzzyIndexBuilderNew                    ,


-- ** setCaseSensitive #method:setCaseSensitive#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderSetCaseSensitiveMethodInfo,
#endif
    fuzzyIndexBuilderSetCaseSensitive       ,


-- ** setMetadata #method:setMetadata#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderSetMetadataMethodInfo  ,
#endif
    fuzzyIndexBuilderSetMetadata            ,


-- ** setMetadataString #method:setMetadataString#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderSetMetadataStringMethodInfo,
#endif
    fuzzyIndexBuilderSetMetadataString      ,


-- ** setMetadataUint32 #method:setMetadataUint32#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderSetMetadataUint32MethodInfo,
#endif
    fuzzyIndexBuilderSetMetadataUint32      ,


-- ** setMetadataUint64 #method:setMetadataUint64#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderSetMetadataUint64MethodInfo,
#endif
    fuzzyIndexBuilderSetMetadataUint64      ,


-- ** write #method:write#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderWriteMethodInfo        ,
#endif
    fuzzyIndexBuilderWrite                  ,


-- ** writeAsync #method:writeAsync#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderWriteAsyncMethodInfo   ,
#endif
    fuzzyIndexBuilderWriteAsync             ,


-- ** writeFinish #method:writeFinish#

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderWriteFinishMethodInfo  ,
#endif
    fuzzyIndexBuilderWriteFinish            ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    FuzzyIndexBuilderCaseSensitivePropertyInfo,
#endif
    constructFuzzyIndexBuilderCaseSensitive ,
#if defined(ENABLE_OVERLOADING)
    fuzzyIndexBuilderCaseSensitive          ,
#endif
    getFuzzyIndexBuilderCaseSensitive       ,
    setFuzzyIndexBuilderCaseSensitive       ,




    ) 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)
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable

#else
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable

#endif

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

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

foreign import ccall "dzl_fuzzy_index_builder_get_type"
    c_dzl_fuzzy_index_builder_get_type :: IO B.Types.GType

instance B.Types.TypedObject FuzzyIndexBuilder where
    glibType :: IO GType
glibType = IO GType
c_dzl_fuzzy_index_builder_get_type

instance B.Types.GObject FuzzyIndexBuilder

-- | Type class for types which can be safely cast to `FuzzyIndexBuilder`, for instance with `toFuzzyIndexBuilder`.
class (SP.GObject o, O.IsDescendantOf FuzzyIndexBuilder o) => IsFuzzyIndexBuilder o
instance (SP.GObject o, O.IsDescendantOf FuzzyIndexBuilder o) => IsFuzzyIndexBuilder o

instance O.HasParentTypes FuzzyIndexBuilder
type instance O.ParentTypes FuzzyIndexBuilder = '[GObject.Object.Object]

-- | Cast to `FuzzyIndexBuilder`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toFuzzyIndexBuilder :: (MIO.MonadIO m, IsFuzzyIndexBuilder o) => o -> m FuzzyIndexBuilder
toFuzzyIndexBuilder :: forall (m :: * -> *) o.
(MonadIO m, IsFuzzyIndexBuilder o) =>
o -> m FuzzyIndexBuilder
toFuzzyIndexBuilder = IO FuzzyIndexBuilder -> m FuzzyIndexBuilder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO FuzzyIndexBuilder -> m FuzzyIndexBuilder)
-> (o -> IO FuzzyIndexBuilder) -> o -> m FuzzyIndexBuilder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr FuzzyIndexBuilder -> FuzzyIndexBuilder)
-> o -> IO FuzzyIndexBuilder
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr FuzzyIndexBuilder -> FuzzyIndexBuilder
FuzzyIndexBuilder

-- | Convert 'FuzzyIndexBuilder' 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 FuzzyIndexBuilder) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_dzl_fuzzy_index_builder_get_type
    gvalueSet_ :: Ptr GValue -> Maybe FuzzyIndexBuilder -> IO ()
gvalueSet_ Ptr GValue
gv Maybe FuzzyIndexBuilder
P.Nothing = Ptr GValue -> Ptr FuzzyIndexBuilder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr FuzzyIndexBuilder
forall a. Ptr a
FP.nullPtr :: FP.Ptr FuzzyIndexBuilder)
    gvalueSet_ Ptr GValue
gv (P.Just FuzzyIndexBuilder
obj) = FuzzyIndexBuilder -> (Ptr FuzzyIndexBuilder -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr FuzzyIndexBuilder
obj (Ptr GValue -> Ptr FuzzyIndexBuilder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe FuzzyIndexBuilder)
gvalueGet_ Ptr GValue
gv = do
        Ptr FuzzyIndexBuilder
ptr <- Ptr GValue -> IO (Ptr FuzzyIndexBuilder)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr FuzzyIndexBuilder)
        if Ptr FuzzyIndexBuilder
ptr Ptr FuzzyIndexBuilder -> Ptr FuzzyIndexBuilder -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr FuzzyIndexBuilder
forall a. Ptr a
FP.nullPtr
        then FuzzyIndexBuilder -> Maybe FuzzyIndexBuilder
forall a. a -> Maybe a
P.Just (FuzzyIndexBuilder -> Maybe FuzzyIndexBuilder)
-> IO FuzzyIndexBuilder -> IO (Maybe FuzzyIndexBuilder)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr FuzzyIndexBuilder -> FuzzyIndexBuilder)
-> Ptr FuzzyIndexBuilder -> IO FuzzyIndexBuilder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr FuzzyIndexBuilder -> FuzzyIndexBuilder
FuzzyIndexBuilder Ptr FuzzyIndexBuilder
ptr
        else Maybe FuzzyIndexBuilder -> IO (Maybe FuzzyIndexBuilder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FuzzyIndexBuilder
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveFuzzyIndexBuilderMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveFuzzyIndexBuilderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveFuzzyIndexBuilderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveFuzzyIndexBuilderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveFuzzyIndexBuilderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveFuzzyIndexBuilderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveFuzzyIndexBuilderMethod "insert" o = FuzzyIndexBuilderInsertMethodInfo
    ResolveFuzzyIndexBuilderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveFuzzyIndexBuilderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveFuzzyIndexBuilderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveFuzzyIndexBuilderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveFuzzyIndexBuilderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveFuzzyIndexBuilderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveFuzzyIndexBuilderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveFuzzyIndexBuilderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveFuzzyIndexBuilderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveFuzzyIndexBuilderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveFuzzyIndexBuilderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveFuzzyIndexBuilderMethod "write" o = FuzzyIndexBuilderWriteMethodInfo
    ResolveFuzzyIndexBuilderMethod "writeAsync" o = FuzzyIndexBuilderWriteAsyncMethodInfo
    ResolveFuzzyIndexBuilderMethod "writeFinish" o = FuzzyIndexBuilderWriteFinishMethodInfo
    ResolveFuzzyIndexBuilderMethod "getCaseSensitive" o = FuzzyIndexBuilderGetCaseSensitiveMethodInfo
    ResolveFuzzyIndexBuilderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveFuzzyIndexBuilderMethod "getDocument" o = FuzzyIndexBuilderGetDocumentMethodInfo
    ResolveFuzzyIndexBuilderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveFuzzyIndexBuilderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveFuzzyIndexBuilderMethod "setCaseSensitive" o = FuzzyIndexBuilderSetCaseSensitiveMethodInfo
    ResolveFuzzyIndexBuilderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveFuzzyIndexBuilderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveFuzzyIndexBuilderMethod "setMetadata" o = FuzzyIndexBuilderSetMetadataMethodInfo
    ResolveFuzzyIndexBuilderMethod "setMetadataString" o = FuzzyIndexBuilderSetMetadataStringMethodInfo
    ResolveFuzzyIndexBuilderMethod "setMetadataUint32" o = FuzzyIndexBuilderSetMetadataUint32MethodInfo
    ResolveFuzzyIndexBuilderMethod "setMetadataUint64" o = FuzzyIndexBuilderSetMetadataUint64MethodInfo
    ResolveFuzzyIndexBuilderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveFuzzyIndexBuilderMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- VVV Prop "case-sensitive"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@case-sensitive@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fuzzyIndexBuilder #caseSensitive
-- @
getFuzzyIndexBuilderCaseSensitive :: (MonadIO m, IsFuzzyIndexBuilder o) => o -> m Bool
getFuzzyIndexBuilderCaseSensitive :: forall (m :: * -> *) o.
(MonadIO m, IsFuzzyIndexBuilder o) =>
o -> m Bool
getFuzzyIndexBuilderCaseSensitive o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"case-sensitive"

-- | Set the value of the “@case-sensitive@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fuzzyIndexBuilder [ #caseSensitive 'Data.GI.Base.Attributes.:=' value ]
-- @
setFuzzyIndexBuilderCaseSensitive :: (MonadIO m, IsFuzzyIndexBuilder o) => o -> Bool -> m ()
setFuzzyIndexBuilderCaseSensitive :: forall (m :: * -> *) o.
(MonadIO m, IsFuzzyIndexBuilder o) =>
o -> Bool -> m ()
setFuzzyIndexBuilderCaseSensitive o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"case-sensitive" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@case-sensitive@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFuzzyIndexBuilderCaseSensitive :: (IsFuzzyIndexBuilder o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructFuzzyIndexBuilderCaseSensitive :: forall o (m :: * -> *).
(IsFuzzyIndexBuilder o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructFuzzyIndexBuilderCaseSensitive Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"case-sensitive" Bool
val

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderCaseSensitivePropertyInfo
instance AttrInfo FuzzyIndexBuilderCaseSensitivePropertyInfo where
    type AttrAllowedOps FuzzyIndexBuilderCaseSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FuzzyIndexBuilderCaseSensitivePropertyInfo = IsFuzzyIndexBuilder
    type AttrSetTypeConstraint FuzzyIndexBuilderCaseSensitivePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FuzzyIndexBuilderCaseSensitivePropertyInfo = (~) Bool
    type AttrTransferType FuzzyIndexBuilderCaseSensitivePropertyInfo = Bool
    type AttrGetType FuzzyIndexBuilderCaseSensitivePropertyInfo = Bool
    type AttrLabel FuzzyIndexBuilderCaseSensitivePropertyInfo = "case-sensitive"
    type AttrOrigin FuzzyIndexBuilderCaseSensitivePropertyInfo = FuzzyIndexBuilder
    attrGet = getFuzzyIndexBuilderCaseSensitive
    attrSet = setFuzzyIndexBuilderCaseSensitive
    attrTransfer _ v = do
        return v
    attrConstruct = constructFuzzyIndexBuilderCaseSensitive
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.caseSensitive"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#g:attr:caseSensitive"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FuzzyIndexBuilder
type instance O.AttributeList FuzzyIndexBuilder = FuzzyIndexBuilderAttributeList
type FuzzyIndexBuilderAttributeList = ('[ '("caseSensitive", FuzzyIndexBuilderCaseSensitivePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
fuzzyIndexBuilderCaseSensitive :: AttrLabelProxy "caseSensitive"
fuzzyIndexBuilderCaseSensitive = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList FuzzyIndexBuilder = FuzzyIndexBuilderSignalList
type FuzzyIndexBuilderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method FuzzyIndexBuilder::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_new" dzl_fuzzy_index_builder_new :: 
    IO (Ptr FuzzyIndexBuilder)

-- | /No description available in the introspection data./
fuzzyIndexBuilderNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m FuzzyIndexBuilder
fuzzyIndexBuilderNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m FuzzyIndexBuilder
fuzzyIndexBuilderNew  = IO FuzzyIndexBuilder -> m FuzzyIndexBuilder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FuzzyIndexBuilder -> m FuzzyIndexBuilder)
-> IO FuzzyIndexBuilder -> m FuzzyIndexBuilder
forall a b. (a -> b) -> a -> b
$ do
    Ptr FuzzyIndexBuilder
result <- IO (Ptr FuzzyIndexBuilder)
dzl_fuzzy_index_builder_new
    Text -> Ptr FuzzyIndexBuilder -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fuzzyIndexBuilderNew" Ptr FuzzyIndexBuilder
result
    FuzzyIndexBuilder
result' <- ((ManagedPtr FuzzyIndexBuilder -> FuzzyIndexBuilder)
-> Ptr FuzzyIndexBuilder -> IO FuzzyIndexBuilder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr FuzzyIndexBuilder -> FuzzyIndexBuilder
FuzzyIndexBuilder) Ptr FuzzyIndexBuilder
result
    FuzzyIndexBuilder -> IO FuzzyIndexBuilder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FuzzyIndexBuilder
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method FuzzyIndexBuilder::get_case_sensitive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_get_case_sensitive" dzl_fuzzy_index_builder_get_case_sensitive :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    IO CInt

-- | /No description available in the introspection data./
fuzzyIndexBuilderGetCaseSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
    a
    -> m Bool
fuzzyIndexBuilderGetCaseSensitive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
a -> m Bool
fuzzyIndexBuilderGetCaseSensitive a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr FuzzyIndexBuilder -> IO CInt
dzl_fuzzy_index_builder_get_case_sensitive Ptr FuzzyIndexBuilder
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderGetCaseSensitiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFuzzyIndexBuilder a) => O.OverloadedMethod FuzzyIndexBuilderGetCaseSensitiveMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderGetCaseSensitive

instance O.OverloadedMethodInfo FuzzyIndexBuilderGetCaseSensitiveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderGetCaseSensitive",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderGetCaseSensitive"
        })


#endif

-- method FuzzyIndexBuilder::get_document
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "document_id"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_get_document" dzl_fuzzy_index_builder_get_document :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    Word64 ->                               -- document_id : TBasicType TUInt64
    IO (Ptr GVariant)

-- | Returns the document that was inserted in a previous call to
-- 'GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderInsert'.
fuzzyIndexBuilderGetDocument ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
    a
    -> Word64
    -> m GVariant
    -- ^ __Returns:__ A t'GVariant'
fuzzyIndexBuilderGetDocument :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
a -> Word64 -> m GVariant
fuzzyIndexBuilderGetDocument a
self Word64
documentId = IO GVariant -> m GVariant
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr GVariant
result <- Ptr FuzzyIndexBuilder -> Word64 -> IO (Ptr GVariant)
dzl_fuzzy_index_builder_get_document Ptr FuzzyIndexBuilder
self' Word64
documentId
    Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fuzzyIndexBuilderGetDocument" Ptr GVariant
result
    GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    GVariant -> IO GVariant
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderGetDocumentMethodInfo
instance (signature ~ (Word64 -> m GVariant), MonadIO m, IsFuzzyIndexBuilder a) => O.OverloadedMethod FuzzyIndexBuilderGetDocumentMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderGetDocument

instance O.OverloadedMethodInfo FuzzyIndexBuilderGetDocumentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderGetDocument",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderGetDocument"
        })


#endif

-- method FuzzyIndexBuilder::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlFuzzyIndexBuilder"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The UTF-8 encoded key for the document"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "document"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The document to store"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "priority"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An optional priority for the keyword."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_insert" dzl_fuzzy_index_builder_insert :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    CString ->                              -- key : TBasicType TUTF8
    Ptr GVariant ->                         -- document : TVariant
    Word32 ->                               -- priority : TBasicType TUInt
    IO Word64

-- | Inserts /@document@/ into the index using /@key@/ as the lookup key.
-- 
-- If a matching document (checked by hashing /@document@/) has already
-- been inserted, only a single instance of the document will be stored.
-- 
-- If /@document@/ is floating, it will be consumed.
-- 
-- /@priority@/ may be used to group results by priority. Priority must be
-- less than 256.
fuzzyIndexBuilderInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.FuzzyIndexBuilder.FuzzyIndexBuilder'
    -> T.Text
    -- ^ /@key@/: The UTF-8 encoded key for the document
    -> GVariant
    -- ^ /@document@/: The document to store
    -> Word32
    -- ^ /@priority@/: An optional priority for the keyword.
    -> m Word64
    -- ^ __Returns:__ The document id registered for /@document@/.
fuzzyIndexBuilderInsert :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
a -> Text -> GVariant -> Word32 -> m Word64
fuzzyIndexBuilderInsert a
self Text
key GVariant
document Word32
priority = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
key' <- Text -> IO CString
textToCString Text
key
    Ptr GVariant
document' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
document
    Word64
result <- Ptr FuzzyIndexBuilder
-> CString -> Ptr GVariant -> Word32 -> IO Word64
dzl_fuzzy_index_builder_insert Ptr FuzzyIndexBuilder
self' CString
key' Ptr GVariant
document' Word32
priority
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
document
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderInsertMethodInfo
instance (signature ~ (T.Text -> GVariant -> Word32 -> m Word64), MonadIO m, IsFuzzyIndexBuilder a) => O.OverloadedMethod FuzzyIndexBuilderInsertMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderInsert

instance O.OverloadedMethodInfo FuzzyIndexBuilderInsertMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderInsert",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderInsert"
        })


#endif

-- method FuzzyIndexBuilder::set_case_sensitive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "case_sensitive"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_set_case_sensitive" dzl_fuzzy_index_builder_set_case_sensitive :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    CInt ->                                 -- case_sensitive : TBasicType TBoolean
    IO ()

-- | /No description available in the introspection data./
fuzzyIndexBuilderSetCaseSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
    a
    -> Bool
    -> m ()
fuzzyIndexBuilderSetCaseSensitive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
a -> Bool -> m ()
fuzzyIndexBuilderSetCaseSensitive a
self Bool
caseSensitive = 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
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let caseSensitive' :: CInt
caseSensitive' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
caseSensitive
    Ptr FuzzyIndexBuilder -> CInt -> IO ()
dzl_fuzzy_index_builder_set_case_sensitive Ptr FuzzyIndexBuilder
self' CInt
caseSensitive'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderSetCaseSensitiveMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFuzzyIndexBuilder a) => O.OverloadedMethod FuzzyIndexBuilderSetCaseSensitiveMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderSetCaseSensitive

instance O.OverloadedMethodInfo FuzzyIndexBuilderSetCaseSensitiveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderSetCaseSensitive",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderSetCaseSensitive"
        })


#endif

-- method FuzzyIndexBuilder::set_metadata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_set_metadata" dzl_fuzzy_index_builder_set_metadata :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    CString ->                              -- key : TBasicType TUTF8
    Ptr GVariant ->                         -- value : TVariant
    IO ()

-- | /No description available in the introspection data./
fuzzyIndexBuilderSetMetadata ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
    a
    -> T.Text
    -> GVariant
    -> m ()
fuzzyIndexBuilderSetMetadata :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
a -> Text -> GVariant -> m ()
fuzzyIndexBuilderSetMetadata a
self Text
key GVariant
value = 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
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
key' <- Text -> IO CString
textToCString Text
key
    Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
    Ptr FuzzyIndexBuilder -> CString -> Ptr GVariant -> IO ()
dzl_fuzzy_index_builder_set_metadata Ptr FuzzyIndexBuilder
self' CString
key' Ptr GVariant
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderSetMetadataMethodInfo
instance (signature ~ (T.Text -> GVariant -> m ()), MonadIO m, IsFuzzyIndexBuilder a) => O.OverloadedMethod FuzzyIndexBuilderSetMetadataMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderSetMetadata

instance O.OverloadedMethodInfo FuzzyIndexBuilderSetMetadataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderSetMetadata",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderSetMetadata"
        })


#endif

-- method FuzzyIndexBuilder::set_metadata_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_set_metadata_string" dzl_fuzzy_index_builder_set_metadata_string :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    CString ->                              -- key : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO ()

-- | /No description available in the introspection data./
fuzzyIndexBuilderSetMetadataString ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
    a
    -> T.Text
    -> T.Text
    -> m ()
fuzzyIndexBuilderSetMetadataString :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
a -> Text -> Text -> m ()
fuzzyIndexBuilderSetMetadataString a
self Text
key Text
value = 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
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
key' <- Text -> IO CString
textToCString Text
key
    CString
value' <- Text -> IO CString
textToCString Text
value
    Ptr FuzzyIndexBuilder -> CString -> CString -> IO ()
dzl_fuzzy_index_builder_set_metadata_string Ptr FuzzyIndexBuilder
self' CString
key' CString
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderSetMetadataStringMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsFuzzyIndexBuilder a) => O.OverloadedMethod FuzzyIndexBuilderSetMetadataStringMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderSetMetadataString

instance O.OverloadedMethodInfo FuzzyIndexBuilderSetMetadataStringMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderSetMetadataString",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderSetMetadataString"
        })


#endif

-- method FuzzyIndexBuilder::set_metadata_uint32
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_set_metadata_uint32" dzl_fuzzy_index_builder_set_metadata_uint32 :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    CString ->                              -- key : TBasicType TUTF8
    Word32 ->                               -- value : TBasicType TUInt32
    IO ()

-- | /No description available in the introspection data./
fuzzyIndexBuilderSetMetadataUint32 ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
    a
    -> T.Text
    -> Word32
    -> m ()
fuzzyIndexBuilderSetMetadataUint32 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
a -> Text -> Word32 -> m ()
fuzzyIndexBuilderSetMetadataUint32 a
self Text
key Word32
value = 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
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
key' <- Text -> IO CString
textToCString Text
key
    Ptr FuzzyIndexBuilder -> CString -> Word32 -> IO ()
dzl_fuzzy_index_builder_set_metadata_uint32 Ptr FuzzyIndexBuilder
self' CString
key' Word32
value
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderSetMetadataUint32MethodInfo
instance (signature ~ (T.Text -> Word32 -> m ()), MonadIO m, IsFuzzyIndexBuilder a) => O.OverloadedMethod FuzzyIndexBuilderSetMetadataUint32MethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderSetMetadataUint32

instance O.OverloadedMethodInfo FuzzyIndexBuilderSetMetadataUint32MethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderSetMetadataUint32",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderSetMetadataUint32"
        })


#endif

-- method FuzzyIndexBuilder::set_metadata_uint64
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_set_metadata_uint64" dzl_fuzzy_index_builder_set_metadata_uint64 :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    CString ->                              -- key : TBasicType TUTF8
    Word64 ->                               -- value : TBasicType TUInt64
    IO ()

-- | /No description available in the introspection data./
fuzzyIndexBuilderSetMetadataUint64 ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
    a
    -> T.Text
    -> Word64
    -> m ()
fuzzyIndexBuilderSetMetadataUint64 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a) =>
a -> Text -> Word64 -> m ()
fuzzyIndexBuilderSetMetadataUint64 a
self Text
key Word64
value = 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
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
key' <- Text -> IO CString
textToCString Text
key
    Ptr FuzzyIndexBuilder -> CString -> Word64 -> IO ()
dzl_fuzzy_index_builder_set_metadata_uint64 Ptr FuzzyIndexBuilder
self' CString
key' Word64
value
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderSetMetadataUint64MethodInfo
instance (signature ~ (T.Text -> Word64 -> m ()), MonadIO m, IsFuzzyIndexBuilder a) => O.OverloadedMethod FuzzyIndexBuilderSetMetadataUint64MethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderSetMetadataUint64

instance O.OverloadedMethodInfo FuzzyIndexBuilderSetMetadataUint64MethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderSetMetadataUint64",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderSetMetadataUint64"
        })


#endif

-- method FuzzyIndexBuilder::write
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "file"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "io_priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_write" dzl_fuzzy_index_builder_write :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    Ptr Gio.File.File ->                    -- file : TInterface (Name {namespace = "Gio", name = "File"})
    Int32 ->                                -- io_priority : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | /No description available in the introspection data./
fuzzyIndexBuilderWrite ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) =>
    a
    -> b
    -> Int32
    -> Maybe (c)
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
fuzzyIndexBuilderWrite :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a, IsFile b,
 IsCancellable c) =>
a -> b -> Int32 -> Maybe c -> m ()
fuzzyIndexBuilderWrite a
self b
file Int32
ioPriority Maybe c
cancellable = 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
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
file' <- b -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
file
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr FuzzyIndexBuilder
-> Ptr File
-> Int32
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
dzl_fuzzy_index_builder_write Ptr FuzzyIndexBuilder
self' Ptr File
file' Int32
ioPriority Ptr Cancellable
maybeCancellable
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
file
        Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderWriteMethodInfo
instance (signature ~ (b -> Int32 -> Maybe (c) -> m ()), MonadIO m, IsFuzzyIndexBuilder a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod FuzzyIndexBuilderWriteMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderWrite

instance O.OverloadedMethodInfo FuzzyIndexBuilderWriteMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderWrite",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderWrite"
        })


#endif

-- method FuzzyIndexBuilder::write_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #DzlFuzzyIndexBuilder"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "file"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GFile to write the index to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "io_priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The priority for IO operations"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An optional #GCancellable or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A callback for completion or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 5
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User data for @callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_write_async" dzl_fuzzy_index_builder_write_async :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    Ptr Gio.File.File ->                    -- file : TInterface (Name {namespace = "Gio", name = "File"})
    Int32 ->                                -- io_priority : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Builds and writes the index to /@file@/. The file format is a
-- GVariant on disk and can be loaded and searched using
-- @/FuzzyIndex/@.
fuzzyIndexBuilderWriteAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: A t'GI.Dazzle.Objects.FuzzyIndexBuilder.FuzzyIndexBuilder'
    -> b
    -- ^ /@file@/: A t'GI.Gio.Interfaces.File.File' to write the index to
    -> Int32
    -- ^ /@ioPriority@/: The priority for IO operations
    -> Maybe (c)
    -- ^ /@cancellable@/: An optional t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing'
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: A callback for completion or 'P.Nothing'
    -> m ()
fuzzyIndexBuilderWriteAsync :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a, IsFile b,
 IsCancellable c) =>
a -> b -> Int32 -> Maybe c -> Maybe AsyncReadyCallback -> m ()
fuzzyIndexBuilderWriteAsync a
self b
file Int32
ioPriority Maybe c
cancellable Maybe AsyncReadyCallback
callback = 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
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
file' <- b -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
file
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr FuzzyIndexBuilder
-> Ptr File
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
dzl_fuzzy_index_builder_write_async Ptr FuzzyIndexBuilder
self' Ptr File
file' Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
file
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderWriteAsyncMethodInfo
instance (signature ~ (b -> Int32 -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsFuzzyIndexBuilder a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod FuzzyIndexBuilderWriteAsyncMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderWriteAsync

instance O.OverloadedMethodInfo FuzzyIndexBuilderWriteAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderWriteAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderWriteAsync"
        })


#endif

-- method FuzzyIndexBuilder::write_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FuzzyIndexBuilder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "dzl_fuzzy_index_builder_write_finish" dzl_fuzzy_index_builder_write_finish :: 
    Ptr FuzzyIndexBuilder ->                -- self : TInterface (Name {namespace = "Dazzle", name = "FuzzyIndexBuilder"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | /No description available in the introspection data./
fuzzyIndexBuilderWriteFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsFuzzyIndexBuilder a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -> b
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
fuzzyIndexBuilderWriteFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFuzzyIndexBuilder a,
 IsAsyncResult b) =>
a -> b -> m ()
fuzzyIndexBuilderWriteFinish a
self b
result_ = 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
$ do
    Ptr FuzzyIndexBuilder
self' <- a -> IO (Ptr FuzzyIndexBuilder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr FuzzyIndexBuilder
-> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
dzl_fuzzy_index_builder_write_finish Ptr FuzzyIndexBuilder
self' Ptr AsyncResult
result_'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data FuzzyIndexBuilderWriteFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsFuzzyIndexBuilder a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod FuzzyIndexBuilderWriteFinishMethodInfo a signature where
    overloadedMethod = fuzzyIndexBuilderWriteFinish

instance O.OverloadedMethodInfo FuzzyIndexBuilderWriteFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FuzzyIndexBuilder.fuzzyIndexBuilderWriteFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FuzzyIndexBuilder.html#v:fuzzyIndexBuilderWriteFinish"
        })


#endif