{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A @GString@ is an object that handles the memory management of a C string.
-- 
-- The emphasis of @GString@ is on text, typically UTF-8. Crucially, the \"str\" member
-- of a @GString@ is guaranteed to have a trailing nul character, and it is therefore
-- always safe to call functions such as @strchr()@ or @strdup()@ on it.
-- 
-- However, a @GString@ can also hold arbitrary binary data, because it has a \"len\" member,
-- which includes any possible embedded nul characters in the data. Conceptually then,
-- @GString@ is like a @GByteArray@ with the addition of many convenience methods for
-- text, and a guaranteed nul terminator.

#if !defined(__HADDOCK_VERSION__)
#define ENABLE_OVERLOADING
#endif

module GI.GLib.Structs.String
    ( 

-- * Exported types
    String(..)                              ,
    newZeroString                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [append]("GI.GLib.Structs.String#g:method:append"), [appendC]("GI.GLib.Structs.String#g:method:appendC"), [appendLen]("GI.GLib.Structs.String#g:method:appendLen"), [appendUnichar]("GI.GLib.Structs.String#g:method:appendUnichar"), [appendUriEscaped]("GI.GLib.Structs.String#g:method:appendUriEscaped"), [asciiDown]("GI.GLib.Structs.String#g:method:asciiDown"), [asciiUp]("GI.GLib.Structs.String#g:method:asciiUp"), [assign]("GI.GLib.Structs.String#g:method:assign"), [copy]("GI.GLib.Structs.String#g:method:copy"), [down]("GI.GLib.Structs.String#g:method:down"), [equal]("GI.GLib.Structs.String#g:method:equal"), [erase]("GI.GLib.Structs.String#g:method:erase"), [free]("GI.GLib.Structs.String#g:method:free"), [freeAndSteal]("GI.GLib.Structs.String#g:method:freeAndSteal"), [freeToBytes]("GI.GLib.Structs.String#g:method:freeToBytes"), [hash]("GI.GLib.Structs.String#g:method:hash"), [insert]("GI.GLib.Structs.String#g:method:insert"), [insertC]("GI.GLib.Structs.String#g:method:insertC"), [insertLen]("GI.GLib.Structs.String#g:method:insertLen"), [insertUnichar]("GI.GLib.Structs.String#g:method:insertUnichar"), [overwrite]("GI.GLib.Structs.String#g:method:overwrite"), [overwriteLen]("GI.GLib.Structs.String#g:method:overwriteLen"), [prepend]("GI.GLib.Structs.String#g:method:prepend"), [prependC]("GI.GLib.Structs.String#g:method:prependC"), [prependLen]("GI.GLib.Structs.String#g:method:prependLen"), [prependUnichar]("GI.GLib.Structs.String#g:method:prependUnichar"), [replace]("GI.GLib.Structs.String#g:method:replace"), [truncate]("GI.GLib.Structs.String#g:method:truncate"), [up]("GI.GLib.Structs.String#g:method:up").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- [setSize]("GI.GLib.Structs.String#g:method:setSize").

#if defined(ENABLE_OVERLOADING)
    ResolveStringMethod                     ,
#endif

-- ** append #method:append#

#if defined(ENABLE_OVERLOADING)
    StringAppendMethodInfo                  ,
#endif
    stringAppend                            ,


-- ** appendC #method:appendC#

#if defined(ENABLE_OVERLOADING)
    StringAppendCMethodInfo                 ,
#endif
    stringAppendC                           ,


-- ** appendLen #method:appendLen#

#if defined(ENABLE_OVERLOADING)
    StringAppendLenMethodInfo               ,
#endif
    stringAppendLen                         ,


-- ** appendUnichar #method:appendUnichar#

#if defined(ENABLE_OVERLOADING)
    StringAppendUnicharMethodInfo           ,
#endif
    stringAppendUnichar                     ,


-- ** appendUriEscaped #method:appendUriEscaped#

#if defined(ENABLE_OVERLOADING)
    StringAppendUriEscapedMethodInfo        ,
#endif
    stringAppendUriEscaped                  ,


-- ** asciiDown #method:asciiDown#

#if defined(ENABLE_OVERLOADING)
    StringAsciiDownMethodInfo               ,
#endif
    stringAsciiDown                         ,


-- ** asciiUp #method:asciiUp#

#if defined(ENABLE_OVERLOADING)
    StringAsciiUpMethodInfo                 ,
#endif
    stringAsciiUp                           ,


-- ** assign #method:assign#

#if defined(ENABLE_OVERLOADING)
    StringAssignMethodInfo                  ,
#endif
    stringAssign                            ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    StringCopyMethodInfo                    ,
#endif
    stringCopy                              ,


-- ** down #method:down#

#if defined(ENABLE_OVERLOADING)
    StringDownMethodInfo                    ,
#endif
    stringDown                              ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    StringEqualMethodInfo                   ,
#endif
    stringEqual                             ,


-- ** erase #method:erase#

#if defined(ENABLE_OVERLOADING)
    StringEraseMethodInfo                   ,
#endif
    stringErase                             ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    StringFreeMethodInfo                    ,
#endif
    stringFree                              ,


-- ** freeAndSteal #method:freeAndSteal#

#if defined(ENABLE_OVERLOADING)
    StringFreeAndStealMethodInfo            ,
#endif
    stringFreeAndSteal                      ,


-- ** freeToBytes #method:freeToBytes#

#if defined(ENABLE_OVERLOADING)
    StringFreeToBytesMethodInfo             ,
#endif
    stringFreeToBytes                       ,


-- ** hash #method:hash#

#if defined(ENABLE_OVERLOADING)
    StringHashMethodInfo                    ,
#endif
    stringHash                              ,


-- ** insert #method:insert#

#if defined(ENABLE_OVERLOADING)
    StringInsertMethodInfo                  ,
#endif
    stringInsert                            ,


-- ** insertC #method:insertC#

#if defined(ENABLE_OVERLOADING)
    StringInsertCMethodInfo                 ,
#endif
    stringInsertC                           ,


-- ** insertLen #method:insertLen#

#if defined(ENABLE_OVERLOADING)
    StringInsertLenMethodInfo               ,
#endif
    stringInsertLen                         ,


-- ** insertUnichar #method:insertUnichar#

#if defined(ENABLE_OVERLOADING)
    StringInsertUnicharMethodInfo           ,
#endif
    stringInsertUnichar                     ,


-- ** new #method:new#

    stringNew                               ,


-- ** newLen #method:newLen#

    stringNewLen                            ,


-- ** newTake #method:newTake#

    stringNewTake                           ,


-- ** overwrite #method:overwrite#

#if defined(ENABLE_OVERLOADING)
    StringOverwriteMethodInfo               ,
#endif
    stringOverwrite                         ,


-- ** overwriteLen #method:overwriteLen#

#if defined(ENABLE_OVERLOADING)
    StringOverwriteLenMethodInfo            ,
#endif
    stringOverwriteLen                      ,


-- ** prepend #method:prepend#

#if defined(ENABLE_OVERLOADING)
    StringPrependMethodInfo                 ,
#endif
    stringPrepend                           ,


-- ** prependC #method:prependC#

#if defined(ENABLE_OVERLOADING)
    StringPrependCMethodInfo                ,
#endif
    stringPrependC                          ,


-- ** prependLen #method:prependLen#

#if defined(ENABLE_OVERLOADING)
    StringPrependLenMethodInfo              ,
#endif
    stringPrependLen                        ,


-- ** prependUnichar #method:prependUnichar#

#if defined(ENABLE_OVERLOADING)
    StringPrependUnicharMethodInfo          ,
#endif
    stringPrependUnichar                    ,


-- ** replace #method:replace#

#if defined(ENABLE_OVERLOADING)
    StringReplaceMethodInfo                 ,
#endif
    stringReplace                           ,


-- ** setSize #method:setSize#

#if defined(ENABLE_OVERLOADING)
    StringSetSizeMethodInfo                 ,
#endif
    stringSetSize                           ,


-- ** sizedNew #method:sizedNew#

    stringSizedNew                          ,


-- ** truncate #method:truncate#

#if defined(ENABLE_OVERLOADING)
    StringTruncateMethodInfo                ,
#endif
    stringTruncate                          ,


-- ** up #method:up#

#if defined(ENABLE_OVERLOADING)
    StringUpMethodInfo                      ,
#endif
    stringUp                                ,




 -- * Properties


-- ** allocatedLen #attr:allocatedLen#
-- | the number of bytes that can be stored in the
--   string before it needs to be reallocated. May be larger than /@len@/.

    getStringAllocatedLen                   ,
    setStringAllocatedLen                   ,
#if defined(ENABLE_OVERLOADING)
    string_allocatedLen                     ,
#endif


-- ** len #attr:len#
-- | contains the length of the string, not including the
--   terminating nul byte.

    getStringLen                            ,
    setStringLen                            ,
#if defined(ENABLE_OVERLOADING)
    string_len                              ,
#endif


-- ** str #attr:str#
-- | points to the character data. It may move as text is added.
--   The /@str@/ field is null-terminated and so
--   can be used as an ordinary C string.

    clearStringStr                          ,
    getStringStr                            ,
    setStringStr                            ,
#if defined(ENABLE_OVERLOADING)
    string_str                              ,
#endif




    ) 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 {-# SOURCE #-} qualified GI.GLib.Structs.Bytes as GLib.Bytes

#else
import {-# SOURCE #-} qualified GI.GLib.Structs.Bytes as GLib.Bytes

#endif

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

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

foreign import ccall "g_gstring_get_type" c_g_gstring_get_type :: 
    IO GType

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

instance B.Types.TypedObject String where
    glibType :: IO GType
glibType = IO GType
c_g_gstring_get_type

instance B.Types.GBoxed String

-- | Convert t'String' 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 String) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_gstring_get_type
    gvalueSet_ :: Ptr GValue -> Maybe String -> IO ()
gvalueSet_ Ptr GValue
gv Maybe String
P.Nothing = Ptr GValue -> Ptr String -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr String
forall a. Ptr a
FP.nullPtr :: FP.Ptr String)
    gvalueSet_ Ptr GValue
gv (P.Just String
obj) = String -> (Ptr String -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr String
obj (Ptr GValue -> Ptr String -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe String)
gvalueGet_ Ptr GValue
gv = do
        ptr <- Ptr GValue -> IO (Ptr String)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr String)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newBoxed String ptr
        else return P.Nothing
        
    

-- | Construct a t'String' struct initialized to zero.
newZeroString :: MonadIO m => m String
newZeroString :: forall (m :: * -> *). MonadIO m => m String
newZeroString = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr String)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
24 IO (Ptr String) -> (Ptr String -> IO String) -> IO String
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr String -> String) -> Ptr String -> IO String
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr String -> String
String

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


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

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

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

string_str :: AttrLabelProxy "str"
string_str = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data StringLenFieldInfo
instance AttrInfo StringLenFieldInfo where
    type AttrBaseTypeConstraint StringLenFieldInfo = (~) String
    type AttrAllowedOps StringLenFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint StringLenFieldInfo = (~) FCT.CSize
    type AttrTransferTypeConstraint StringLenFieldInfo = (~)FCT.CSize
    type AttrTransferType StringLenFieldInfo = FCT.CSize
    type AttrGetType StringLenFieldInfo = FCT.CSize
    type AttrLabel StringLenFieldInfo = "len"
    type AttrOrigin StringLenFieldInfo = String
    attrGet = getStringLen
    attrSet = setStringLen
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.len"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#g:attr:len"
        })

string_len :: AttrLabelProxy "len"
string_len = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data StringAllocatedLenFieldInfo
instance AttrInfo StringAllocatedLenFieldInfo where
    type AttrBaseTypeConstraint StringAllocatedLenFieldInfo = (~) String
    type AttrAllowedOps StringAllocatedLenFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint StringAllocatedLenFieldInfo = (~) FCT.CSize
    type AttrTransferTypeConstraint StringAllocatedLenFieldInfo = (~)FCT.CSize
    type AttrTransferType StringAllocatedLenFieldInfo = FCT.CSize
    type AttrGetType StringAllocatedLenFieldInfo = FCT.CSize
    type AttrLabel StringAllocatedLenFieldInfo = "allocated_len"
    type AttrOrigin StringAllocatedLenFieldInfo = String
    attrGet = getStringAllocatedLen
    attrSet = setStringAllocatedLen
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.allocatedLen"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#g:attr:allocatedLen"
        })

string_allocatedLen :: AttrLabelProxy "allocatedLen"
string_allocatedLen = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList String
type instance O.AttributeList String = StringAttributeList
type StringAttributeList = ('[ '("str", StringStrFieldInfo), '("len", StringLenFieldInfo), '("allocatedLen", StringAllocatedLenFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method String::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "init"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the initial text to copy into the string, or %NULL to\n  start with an empty string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_new" g_string_new :: 
    CString ->                              -- init : TBasicType TUTF8
    IO (Ptr String)

-- | Creates a new t'GI.GLib.Structs.String.String', initialized with the given string.
stringNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    -- ^ /@init@/: the initial text to copy into the string, or 'P.Nothing' to
    --   start with an empty string
    -> m String
    -- ^ __Returns:__ the new t'GI.GLib.Structs.String.String'
stringNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m String
stringNew Maybe Text
init = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    maybeInit <- case Maybe Text
init of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jInit -> do
            jInit' <- Text -> IO CString
textToCString Text
jInit
            return jInit'
    result <- g_string_new maybeInit
    checkUnexpectedReturnNULL "stringNew" result
    result' <- (wrapBoxed String) result
    freeMem maybeInit
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method String::new_len
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "init"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "initial contents of the string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "length of @init to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_new_len" g_string_new_len :: 
    CString ->                              -- init : TBasicType TUTF8
    DI.Int64 ->                             -- len : TBasicType TSSize
    IO (Ptr String)

-- | Creates a new t'GI.GLib.Structs.String.String' with /@len@/ bytes of the /@init@/ buffer.
-- Because a length is provided, /@init@/ need not be nul-terminated,
-- and can contain embedded nul bytes.
-- 
-- Since this function does not stop at nul bytes, it is the caller\'s
-- responsibility to ensure that /@init@/ has at least /@len@/ addressable
-- bytes.
stringNewLen ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@init@/: initial contents of the string
    -> DI.Int64
    -- ^ /@len@/: length of /@init@/ to use
    -> m String
    -- ^ __Returns:__ a new t'GI.GLib.Structs.String.String'
stringNewLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Int64 -> m String
stringNewLen Text
init Int64
len = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    init' <- Text -> IO CString
textToCString Text
init
    result <- g_string_new_len init' len
    checkUnexpectedReturnNULL "stringNewLen" result
    result' <- (wrapBoxed String) result
    freeMem init'
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method String::new_take
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "init"
--           , argType = TBasicType TUTF8
--           , argCType = Just "gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "initial text used as the string.\n    Ownership of the string is transferred to the #GString.\n    Passing %NULL creates an empty string."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_new_take" g_string_new_take :: 
    CString ->                              -- init : TBasicType TUTF8
    IO (Ptr String)

-- | Creates a new t'GI.GLib.Structs.String.String', initialized with the given string.
-- 
-- After this call, /@init@/ belongs to the t'GI.GLib.Structs.String.String' and may no longer be
-- modified by the caller. The memory of /@init@/ has to be dynamically
-- allocated and will eventually be freed with 'GI.GLib.Functions.free'.
-- 
-- /Since: 2.78/
stringNewTake ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    -- ^ /@init@/: initial text used as the string.
    --     Ownership of the string is transferred to the t'GI.GLib.Structs.String.String'.
    --     Passing 'P.Nothing' creates an empty string.
    -> m String
    -- ^ __Returns:__ the new t'GI.GLib.Structs.String.String'
stringNewTake :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m String
stringNewTake Maybe Text
init = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    maybeInit <- case Maybe Text
init of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jInit -> do
            jInit' <- Text -> IO CString
textToCString Text
jInit
            return jInit'
    result <- g_string_new_take maybeInit
    checkUnexpectedReturnNULL "stringNewTake" result
    result' <- (wrapBoxed String) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method String::sized_new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "dfl_size"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the default size of the space allocated to hold the string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_sized_new" g_string_sized_new :: 
    FCT.CSize ->                            -- dfl_size : TBasicType TSize
    IO (Ptr String)

-- | Creates a new t'GI.GLib.Structs.String.String', with enough space for /@dflSize@/
-- bytes. This is useful if you are going to add a lot of
-- text to the string and don\'t want it to be reallocated
-- too often.
stringSizedNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FCT.CSize
    -- ^ /@dflSize@/: the default size of the space allocated to hold the string
    -> m String
    -- ^ __Returns:__ the new t'GI.GLib.Structs.String.String'
stringSizedNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CSize -> m String
stringSizedNew CSize
dflSize = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    result <- CSize -> IO (Ptr String)
g_string_sized_new CSize
dflSize
    checkUnexpectedReturnNULL "stringSizedNew" result
    result' <- (wrapBoxed String) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method String::append
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "val"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string to append onto the end of @string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_append" g_string_append :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- val : TBasicType TUTF8
    IO (Ptr String)

-- | Adds a string onto the end of a t'GI.GLib.Structs.String.String', expanding
-- it if necessary.
stringAppend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> T.Text
    -- ^ /@val@/: the string to append onto the end of /@string@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> m String
stringAppend String
string Text
val = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    val' <- textToCString val
    result <- g_string_append string' val'
    checkUnexpectedReturnNULL "stringAppend" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem val'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringAppendMethodInfo
instance (signature ~ (T.Text -> m String), MonadIO m) => O.OverloadedMethod StringAppendMethodInfo String signature where
    overloadedMethod = stringAppend

instance O.OverloadedMethodInfo StringAppendMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringAppend",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringAppend"
        })


#endif

-- method String::append_c
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c"
--           , argType = TBasicType TInt8
--           , argCType = Just "gchar"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the byte to append onto the end of @string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_append_c" g_string_append_c :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    Int8 ->                                 -- c : TBasicType TInt8
    IO (Ptr String)

-- | Adds a byte onto the end of a t'GI.GLib.Structs.String.String', expanding
-- it if necessary.
stringAppendC ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> Int8
    -- ^ /@c@/: the byte to append onto the end of /@string@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringAppendC :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int8 -> m String
stringAppendC String
string Int8
c = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_append_c string' c
    checkUnexpectedReturnNULL "stringAppendC" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringAppendCMethodInfo
instance (signature ~ (Int8 -> m String), MonadIO m) => O.OverloadedMethod StringAppendCMethodInfo String signature where
    overloadedMethod = stringAppendC

instance O.OverloadedMethodInfo StringAppendCMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringAppendC",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringAppendC"
        })


#endif

-- method String::append_len
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "val"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "bytes to append" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "number of bytes of @val to use, or -1 for all of @val"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_append_len" g_string_append_len :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- val : TBasicType TUTF8
    DI.Int64 ->                             -- len : TBasicType TSSize
    IO (Ptr String)

-- | Appends /@len@/ bytes of /@val@/ to /@string@/.
-- 
-- If /@len@/ is positive, /@val@/ may contain embedded nuls and need
-- not be nul-terminated. It is the caller\'s responsibility to
-- ensure that /@val@/ has at least /@len@/ addressable bytes.
-- 
-- If /@len@/ is negative, /@val@/ must be nul-terminated and /@len@/
-- is considered to request the entire string length. This
-- makes 'GI.GLib.Structs.String.stringAppendLen' equivalent to 'GI.GLib.Structs.String.stringAppend'.
stringAppendLen ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> T.Text
    -- ^ /@val@/: bytes to append
    -> DI.Int64
    -- ^ /@len@/: number of bytes of /@val@/ to use, or -1 for all of /@val@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringAppendLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Int64 -> m String
stringAppendLen String
string Text
val Int64
len = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    val' <- textToCString val
    result <- g_string_append_len string' val' len
    checkUnexpectedReturnNULL "stringAppendLen" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem val'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringAppendLenMethodInfo
instance (signature ~ (T.Text -> DI.Int64 -> m String), MonadIO m) => O.OverloadedMethod StringAppendLenMethodInfo String signature where
    overloadedMethod = stringAppendLen

instance O.OverloadedMethodInfo StringAppendLenMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringAppendLen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringAppendLen"
        })


#endif

-- method String::append_unichar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wc"
--           , argType = TBasicType TUniChar
--           , argCType = Just "gunichar"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a Unicode character"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_append_unichar" g_string_append_unichar :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CInt ->                                 -- wc : TBasicType TUniChar
    IO (Ptr String)

-- | Converts a Unicode character into UTF-8, and appends it
-- to the string.
stringAppendUnichar ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> Char
    -- ^ /@wc@/: a Unicode character
    -> m String
    -- ^ __Returns:__ /@string@/
stringAppendUnichar :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Char -> m String
stringAppendUnichar String
string Char
wc = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    let wc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
SP.ord) Char
wc
    result <- g_string_append_unichar string' wc'
    checkUnexpectedReturnNULL "stringAppendUnichar" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringAppendUnicharMethodInfo
instance (signature ~ (Char -> m String), MonadIO m) => O.OverloadedMethod StringAppendUnicharMethodInfo String signature where
    overloadedMethod = stringAppendUnichar

instance O.OverloadedMethodInfo StringAppendUnicharMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringAppendUnichar",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringAppendUnichar"
        })


#endif

-- method String::append_uri_escaped
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unescaped"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reserved_chars_allowed"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a string of reserved characters allowed\n    to be used, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_utf8"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "set %TRUE if the escaped string may include UTF8 characters"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_append_uri_escaped" g_string_append_uri_escaped :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- unescaped : TBasicType TUTF8
    CString ->                              -- reserved_chars_allowed : TBasicType TUTF8
    CInt ->                                 -- allow_utf8 : TBasicType TBoolean
    IO (Ptr String)

-- | Appends /@unescaped@/ to /@string@/, escaping any characters that
-- are reserved in URIs using URI-style escape sequences.
-- 
-- /Since: 2.16/
stringAppendUriEscaped ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> T.Text
    -- ^ /@unescaped@/: a string
    -> T.Text
    -- ^ /@reservedCharsAllowed@/: a string of reserved characters allowed
    --     to be used, or 'P.Nothing'
    -> Bool
    -- ^ /@allowUtf8@/: set 'P.True' if the escaped string may include UTF8 characters
    -> m String
    -- ^ __Returns:__ /@string@/
stringAppendUriEscaped :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Text -> Bool -> m String
stringAppendUriEscaped String
string Text
unescaped Text
reservedCharsAllowed Bool
allowUtf8 = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    unescaped' <- textToCString unescaped
    reservedCharsAllowed' <- textToCString reservedCharsAllowed
    let allowUtf8' = (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
allowUtf8
    result <- g_string_append_uri_escaped string' unescaped' reservedCharsAllowed' allowUtf8'
    checkUnexpectedReturnNULL "stringAppendUriEscaped" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem unescaped'
    freeMem reservedCharsAllowed'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringAppendUriEscapedMethodInfo
instance (signature ~ (T.Text -> T.Text -> Bool -> m String), MonadIO m) => O.OverloadedMethod StringAppendUriEscapedMethodInfo String signature where
    overloadedMethod = stringAppendUriEscaped

instance O.OverloadedMethodInfo StringAppendUriEscapedMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringAppendUriEscaped",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringAppendUriEscaped"
        })


#endif

-- method String::ascii_down
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_ascii_down" g_string_ascii_down :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    IO (Ptr String)

-- | Converts all uppercase ASCII letters to lowercase ASCII letters.
stringAsciiDown ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a GString
    -> m String
    -- ^ __Returns:__ passed-in /@string@/ pointer, with all the
    --     uppercase characters converted to lowercase in place,
    --     with semantics that exactly match 'GI.GLib.Functions.asciiTolower'.
stringAsciiDown :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringAsciiDown String
string = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_ascii_down string'
    checkUnexpectedReturnNULL "stringAsciiDown" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringAsciiDownMethodInfo
instance (signature ~ (m String), MonadIO m) => O.OverloadedMethod StringAsciiDownMethodInfo String signature where
    overloadedMethod = stringAsciiDown

instance O.OverloadedMethodInfo StringAsciiDownMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringAsciiDown",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringAsciiDown"
        })


#endif

-- method String::ascii_up
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_ascii_up" g_string_ascii_up :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    IO (Ptr String)

-- | Converts all lowercase ASCII letters to uppercase ASCII letters.
stringAsciiUp ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a GString
    -> m String
    -- ^ __Returns:__ passed-in /@string@/ pointer, with all the
    --     lowercase characters converted to uppercase in place,
    --     with semantics that exactly match 'GI.GLib.Functions.asciiToupper'.
stringAsciiUp :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringAsciiUp String
string = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_ascii_up string'
    checkUnexpectedReturnNULL "stringAsciiUp" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringAsciiUpMethodInfo
instance (signature ~ (m String), MonadIO m) => O.OverloadedMethod StringAsciiUpMethodInfo String signature where
    overloadedMethod = stringAsciiUp

instance O.OverloadedMethodInfo StringAsciiUpMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringAsciiUp",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringAsciiUp"
        })


#endif

-- method String::assign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the destination #GString. Its current contents\n         are destroyed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rval"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string to copy into @string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_assign" g_string_assign :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- rval : TBasicType TUTF8
    IO (Ptr String)

-- | Copies the bytes from a string into a t'GI.GLib.Structs.String.String',
-- destroying any previous contents. It is rather like
-- the standard @/strcpy()/@ function, except that you do not
-- have to worry about having enough space to copy the string.
stringAssign ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: the destination t'GI.GLib.Structs.String.String'. Its current contents
    --          are destroyed.
    -> T.Text
    -- ^ /@rval@/: the string to copy into /@string@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringAssign :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> m String
stringAssign String
string Text
rval = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    rval' <- textToCString rval
    result <- g_string_assign string' rval'
    checkUnexpectedReturnNULL "stringAssign" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem rval'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringAssignMethodInfo
instance (signature ~ (T.Text -> m String), MonadIO m) => O.OverloadedMethod StringAssignMethodInfo String signature where
    overloadedMethod = stringAssign

instance O.OverloadedMethodInfo StringAssignMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringAssign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringAssign"
        })


#endif

-- method String::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_copy" g_string_copy :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    IO (Ptr String)

-- | Copies the t'GI.GLib.Structs.String.String' instance and its contents.
-- 
-- This will preserve the allocation length of the t'GI.GLib.Structs.String.String' in the
-- copy.
-- 
-- /Since: 2.86/
stringCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a string
    -> m String
    -- ^ __Returns:__ a copy of /@string@/
stringCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringCopy String
string = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_copy string'
    checkUnexpectedReturnNULL "stringCopy" result
    result' <- (wrapBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringCopyMethodInfo
instance (signature ~ (m String), MonadIO m) => O.OverloadedMethod StringCopyMethodInfo String signature where
    overloadedMethod = stringCopy

instance O.OverloadedMethodInfo StringCopyMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringCopy"
        })


#endif

-- method String::down
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_down" g_string_down :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    IO (Ptr String)

{-# DEPRECATED stringDown ["(Since version 2.2)","This function uses the locale-specific","    @/tolower()/@ function, which is almost never the right thing.","    Use 'GI.GLib.Structs.String.stringAsciiDown' or 'GI.GLib.Functions.utf8Strdown' instead."] #-}
-- | Converts a t'GI.GLib.Structs.String.String' to lowercase.
stringDown ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> m String
    -- ^ __Returns:__ the t'GI.GLib.Structs.String.String'
stringDown :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringDown String
string = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_down string'
    checkUnexpectedReturnNULL "stringDown" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringDownMethodInfo
instance (signature ~ (m String), MonadIO m) => O.OverloadedMethod StringDownMethodInfo String signature where
    overloadedMethod = stringDown

instance O.OverloadedMethodInfo StringDownMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringDown",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringDown"
        })


#endif

-- method String::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "v"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "const GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "v2"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "const GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "another #GString" , 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 "g_string_equal" g_string_equal :: 
    Ptr String ->                           -- v : TInterface (Name {namespace = "GLib", name = "String"})
    Ptr String ->                           -- v2 : TInterface (Name {namespace = "GLib", name = "String"})
    IO CInt

-- | Compares two strings for equality, returning 'P.True' if they are equal.
-- For use with t'GI.GLib.Structs.HashTable.HashTable'.
stringEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@v@/: a t'GI.GLib.Structs.String.String'
    -> String
    -- ^ /@v2@/: another t'GI.GLib.Structs.String.String'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the strings are the same length and contain the
    --     same bytes
stringEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> String -> m Bool
stringEqual String
v String
v2 = 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
    v' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
v
    v2' <- unsafeManagedPtrGetPtr v2
    result <- g_string_equal v' v2'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr v
    touchManagedPtr v2
    return result'

#if defined(ENABLE_OVERLOADING)
data StringEqualMethodInfo
instance (signature ~ (String -> m Bool), MonadIO m) => O.OverloadedMethod StringEqualMethodInfo String signature where
    overloadedMethod = stringEqual

instance O.OverloadedMethodInfo StringEqualMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringEqual",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringEqual"
        })


#endif

-- method String::erase
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position of the content to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the number of bytes to remove, or -1 to remove all\n      following bytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_erase" g_string_erase :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    DI.Int64 ->                             -- pos : TBasicType TSSize
    DI.Int64 ->                             -- len : TBasicType TSSize
    IO (Ptr String)

-- | Removes /@len@/ bytes from a t'GI.GLib.Structs.String.String', starting at position /@pos@/.
-- The rest of the t'GI.GLib.Structs.String.String' is shifted down to fill the gap.
stringErase ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> DI.Int64
    -- ^ /@pos@/: the position of the content to remove
    -> DI.Int64
    -- ^ /@len@/: the number of bytes to remove, or -1 to remove all
    --       following bytes
    -> m String
    -- ^ __Returns:__ /@string@/
stringErase :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Int64 -> m String
stringErase String
string Int64
pos Int64
len = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_erase string' pos len
    checkUnexpectedReturnNULL "stringErase" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringEraseMethodInfo
instance (signature ~ (DI.Int64 -> DI.Int64 -> m String), MonadIO m) => O.OverloadedMethod StringEraseMethodInfo String signature where
    overloadedMethod = stringErase

instance O.OverloadedMethodInfo StringEraseMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringErase",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringErase"
        })


#endif

-- method String::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "free_segment"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if %TRUE, the actual character data is freed as well"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_string_free" g_string_free :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CInt ->                                 -- free_segment : TBasicType TBoolean
    IO CString

-- | Frees the memory allocated for the t'GI.GLib.Structs.String.String'.
-- If /@freeSegment@/ is 'P.True' it also frees the character data.  If
-- it\'s 'P.False', the caller gains ownership of the buffer and must
-- free it after use with 'GI.GLib.Functions.free'.
-- 
-- Instead of passing 'P.False' to this function, consider using
-- 'GI.GLib.Structs.String.stringFreeAndSteal'.
stringFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> Bool
    -- ^ /@freeSegment@/: if 'P.True', the actual character data is freed as well
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the character data of /@string@/
    --          (i.e. 'P.Nothing' if /@freeSegment@/ is 'P.True')
stringFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Bool -> m (Maybe Text)
stringFree String
string Bool
freeSegment = 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
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed String
string
    let freeSegment' = (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
freeSegment
    result <- g_string_free string' freeSegment'
    maybeResult <- convertIfNonNull result $ \CString
result' -> do
        result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        freeMem result'
        return result''
    touchManagedPtr string
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data StringFreeMethodInfo
instance (signature ~ (Bool -> m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod StringFreeMethodInfo String signature where
    overloadedMethod = stringFree

instance O.OverloadedMethodInfo StringFreeMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringFree"
        })


#endif

-- method String::free_and_steal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_string_free_and_steal" g_string_free_and_steal :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    IO CString

-- | Frees the memory allocated for the t'GI.GLib.Structs.String.String'.
-- 
-- The caller gains ownership of the buffer and
-- must free it after use with 'GI.GLib.Functions.free'.
-- 
-- /Since: 2.76/
stringFreeAndSteal ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> m T.Text
    -- ^ __Returns:__ the character data of /@string@/
stringFreeAndSteal :: forall (m :: * -> *). (HasCallStack, MonadIO m) => String -> m Text
stringFreeAndSteal String
string = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed String
string
    result <- g_string_free_and_steal string'
    checkUnexpectedReturnNULL "stringFreeAndSteal" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringFreeAndStealMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod StringFreeAndStealMethodInfo String signature where
    overloadedMethod = stringFreeAndSteal

instance O.OverloadedMethodInfo StringFreeAndStealMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringFreeAndSteal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringFreeAndSteal"
        })


#endif

-- method String::free_to_bytes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_free_to_bytes" g_string_free_to_bytes :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    IO (Ptr GLib.Bytes.Bytes)

-- | Transfers ownership of the contents of /@string@/ to a newly allocated
-- t'GI.GLib.Structs.Bytes.Bytes'.  The t'GI.GLib.Structs.String.String' structure itself is deallocated, and it is
-- therefore invalid to use /@string@/ after invoking this function.
-- 
-- Note that while t'GI.GLib.Structs.String.String' ensures that its buffer always has a
-- trailing nul character (not reflected in its \"len\"), the returned
-- t'GI.GLib.Structs.Bytes.Bytes' does not include this extra nul; i.e. it has length exactly
-- equal to the \"len\" member.
-- 
-- /Since: 2.34/
stringFreeToBytes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> m GLib.Bytes.Bytes
    -- ^ __Returns:__ A newly allocated t'GI.GLib.Structs.Bytes.Bytes' containing contents of /@string@/; /@string@/ itself is freed
stringFreeToBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m Bytes
stringFreeToBytes String
string = IO Bytes -> m Bytes
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bytes -> m Bytes) -> IO Bytes -> m Bytes
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed String
string
    result <- g_string_free_to_bytes string'
    checkUnexpectedReturnNULL "stringFreeToBytes" result
    result' <- (wrapBoxed GLib.Bytes.Bytes) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringFreeToBytesMethodInfo
instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m) => O.OverloadedMethod StringFreeToBytesMethodInfo String signature where
    overloadedMethod = stringFreeToBytes

instance O.OverloadedMethodInfo StringFreeToBytesMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringFreeToBytes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringFreeToBytes"
        })


#endif

-- method String::hash
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "str"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "const GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string to hash" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_string_hash" g_string_hash :: 
    Ptr String ->                           -- str : TInterface (Name {namespace = "GLib", name = "String"})
    IO Word32

-- | Creates a hash code for /@str@/; for use with t'GI.GLib.Structs.HashTable.HashTable'.
stringHash ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@str@/: a string to hash
    -> m Word32
    -- ^ __Returns:__ hash code for /@str@/
stringHash :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m Word32
stringHash String
str = 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
$ do
    str' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
str
    result <- g_string_hash str'
    touchManagedPtr str
    return result

#if defined(ENABLE_OVERLOADING)
data StringHashMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod StringHashMethodInfo String signature where
    overloadedMethod = stringHash

instance O.OverloadedMethodInfo StringHashMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringHash",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringHash"
        })


#endif

-- method String::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position to insert the copy of the string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "val"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string to insert"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_insert" g_string_insert :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    DI.Int64 ->                             -- pos : TBasicType TSSize
    CString ->                              -- val : TBasicType TUTF8
    IO (Ptr String)

-- | Inserts a copy of a string into a t'GI.GLib.Structs.String.String',
-- expanding it if necessary.
stringInsert ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> DI.Int64
    -- ^ /@pos@/: the position to insert the copy of the string
    -> T.Text
    -- ^ /@val@/: the string to insert
    -> m String
    -- ^ __Returns:__ /@string@/
stringInsert :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Text -> m String
stringInsert String
string Int64
pos Text
val = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    val' <- textToCString val
    result <- g_string_insert string' pos val'
    checkUnexpectedReturnNULL "stringInsert" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem val'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringInsertMethodInfo
instance (signature ~ (DI.Int64 -> T.Text -> m String), MonadIO m) => O.OverloadedMethod StringInsertMethodInfo String signature where
    overloadedMethod = stringInsert

instance O.OverloadedMethodInfo StringInsertMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringInsert",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringInsert"
        })


#endif

-- method String::insert_c
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position to insert the byte"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c"
--           , argType = TBasicType TInt8
--           , argCType = Just "gchar"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the byte to insert" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_insert_c" g_string_insert_c :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    DI.Int64 ->                             -- pos : TBasicType TSSize
    Int8 ->                                 -- c : TBasicType TInt8
    IO (Ptr String)

-- | Inserts a byte into a t'GI.GLib.Structs.String.String', expanding it if necessary.
stringInsertC ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> DI.Int64
    -- ^ /@pos@/: the position to insert the byte
    -> Int8
    -- ^ /@c@/: the byte to insert
    -> m String
    -- ^ __Returns:__ /@string@/
stringInsertC :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Int8 -> m String
stringInsertC String
string Int64
pos Int8
c = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_insert_c string' pos c
    checkUnexpectedReturnNULL "stringInsertC" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringInsertCMethodInfo
instance (signature ~ (DI.Int64 -> Int8 -> m String), MonadIO m) => O.OverloadedMethod StringInsertCMethodInfo String signature where
    overloadedMethod = stringInsertC

instance O.OverloadedMethodInfo StringInsertCMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringInsertC",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringInsertC"
        })


#endif

-- method String::insert_len
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "position in @string where insertion should\n      happen, or -1 for at the end"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "val"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "bytes to insert" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "number of bytes of @val to insert, or -1 for all of @val"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_insert_len" g_string_insert_len :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    DI.Int64 ->                             -- pos : TBasicType TSSize
    CString ->                              -- val : TBasicType TUTF8
    DI.Int64 ->                             -- len : TBasicType TSSize
    IO (Ptr String)

-- | Inserts /@len@/ bytes of /@val@/ into /@string@/ at /@pos@/.
-- 
-- If /@len@/ is positive, /@val@/ may contain embedded nuls and need
-- not be nul-terminated. It is the caller\'s responsibility to
-- ensure that /@val@/ has at least /@len@/ addressable bytes.
-- 
-- If /@len@/ is negative, /@val@/ must be nul-terminated and /@len@/
-- is considered to request the entire string length.
-- 
-- If /@pos@/ is -1, bytes are inserted at the end of the string.
stringInsertLen ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> DI.Int64
    -- ^ /@pos@/: position in /@string@/ where insertion should
    --       happen, or -1 for at the end
    -> T.Text
    -- ^ /@val@/: bytes to insert
    -> DI.Int64
    -- ^ /@len@/: number of bytes of /@val@/ to insert, or -1 for all of /@val@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringInsertLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Text -> Int64 -> m String
stringInsertLen String
string Int64
pos Text
val Int64
len = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    val' <- textToCString val
    result <- g_string_insert_len string' pos val' len
    checkUnexpectedReturnNULL "stringInsertLen" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem val'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringInsertLenMethodInfo
instance (signature ~ (DI.Int64 -> T.Text -> DI.Int64 -> m String), MonadIO m) => O.OverloadedMethod StringInsertLenMethodInfo String signature where
    overloadedMethod = stringInsertLen

instance O.OverloadedMethodInfo StringInsertLenMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringInsertLen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringInsertLen"
        })


#endif

-- method String::insert_unichar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the position at which to insert character, or -1\n    to append at the end of the string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wc"
--           , argType = TBasicType TUniChar
--           , argCType = Just "gunichar"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a Unicode character"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_insert_unichar" g_string_insert_unichar :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    DI.Int64 ->                             -- pos : TBasicType TSSize
    CInt ->                                 -- wc : TBasicType TUniChar
    IO (Ptr String)

-- | Converts a Unicode character into UTF-8, and insert it
-- into the string at the given position.
stringInsertUnichar ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> DI.Int64
    -- ^ /@pos@/: the position at which to insert character, or -1
    --     to append at the end of the string
    -> Char
    -- ^ /@wc@/: a Unicode character
    -> m String
    -- ^ __Returns:__ /@string@/
stringInsertUnichar :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Char -> m String
stringInsertUnichar String
string Int64
pos Char
wc = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    let wc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
SP.ord) Char
wc
    result <- g_string_insert_unichar string' pos wc'
    checkUnexpectedReturnNULL "stringInsertUnichar" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringInsertUnicharMethodInfo
instance (signature ~ (DI.Int64 -> Char -> m String), MonadIO m) => O.OverloadedMethod StringInsertUnicharMethodInfo String signature where
    overloadedMethod = stringInsertUnichar

instance O.OverloadedMethodInfo StringInsertUnicharMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringInsertUnichar",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringInsertUnichar"
        })


#endif

-- method String::overwrite
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position at which to start overwriting"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "val"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the string that will overwrite the @string starting at @pos"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_overwrite" g_string_overwrite :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    FCT.CSize ->                            -- pos : TBasicType TSize
    CString ->                              -- val : TBasicType TUTF8
    IO (Ptr String)

-- | Overwrites part of a string, lengthening it if necessary.
-- 
-- /Since: 2.14/
stringOverwrite ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> FCT.CSize
    -- ^ /@pos@/: the position at which to start overwriting
    -> T.Text
    -- ^ /@val@/: the string that will overwrite the /@string@/ starting at /@pos@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringOverwrite :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> CSize -> Text -> m String
stringOverwrite String
string CSize
pos Text
val = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    val' <- textToCString val
    result <- g_string_overwrite string' pos val'
    checkUnexpectedReturnNULL "stringOverwrite" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem val'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringOverwriteMethodInfo
instance (signature ~ (FCT.CSize -> T.Text -> m String), MonadIO m) => O.OverloadedMethod StringOverwriteMethodInfo String signature where
    overloadedMethod = stringOverwrite

instance O.OverloadedMethodInfo StringOverwriteMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringOverwrite",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringOverwrite"
        })


#endif

-- method String::overwrite_len
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position at which to start overwriting"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "val"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the string that will overwrite the @string starting at @pos"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of bytes to write from @val"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_overwrite_len" g_string_overwrite_len :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    FCT.CSize ->                            -- pos : TBasicType TSize
    CString ->                              -- val : TBasicType TUTF8
    DI.Int64 ->                             -- len : TBasicType TSSize
    IO (Ptr String)

-- | Overwrites part of a string, lengthening it if necessary.
-- This function will work with embedded nuls.
-- 
-- /Since: 2.14/
stringOverwriteLen ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> FCT.CSize
    -- ^ /@pos@/: the position at which to start overwriting
    -> T.Text
    -- ^ /@val@/: the string that will overwrite the /@string@/ starting at /@pos@/
    -> DI.Int64
    -- ^ /@len@/: the number of bytes to write from /@val@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringOverwriteLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> CSize -> Text -> Int64 -> m String
stringOverwriteLen String
string CSize
pos Text
val Int64
len = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    val' <- textToCString val
    result <- g_string_overwrite_len string' pos val' len
    checkUnexpectedReturnNULL "stringOverwriteLen" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem val'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringOverwriteLenMethodInfo
instance (signature ~ (FCT.CSize -> T.Text -> DI.Int64 -> m String), MonadIO m) => O.OverloadedMethod StringOverwriteLenMethodInfo String signature where
    overloadedMethod = stringOverwriteLen

instance O.OverloadedMethodInfo StringOverwriteLenMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringOverwriteLen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringOverwriteLen"
        })


#endif

-- method String::prepend
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "val"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string to prepend on the start of @string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_prepend" g_string_prepend :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- val : TBasicType TUTF8
    IO (Ptr String)

-- | Adds a string on to the start of a t'GI.GLib.Structs.String.String',
-- expanding it if necessary.
stringPrepend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> T.Text
    -- ^ /@val@/: the string to prepend on the start of /@string@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringPrepend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> m String
stringPrepend String
string Text
val = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    val' <- textToCString val
    result <- g_string_prepend string' val'
    checkUnexpectedReturnNULL "stringPrepend" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem val'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringPrependMethodInfo
instance (signature ~ (T.Text -> m String), MonadIO m) => O.OverloadedMethod StringPrependMethodInfo String signature where
    overloadedMethod = stringPrepend

instance O.OverloadedMethodInfo StringPrependMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringPrepend",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringPrepend"
        })


#endif

-- method String::prepend_c
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c"
--           , argType = TBasicType TInt8
--           , argCType = Just "gchar"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the byte to prepend on the start of the #GString"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_prepend_c" g_string_prepend_c :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    Int8 ->                                 -- c : TBasicType TInt8
    IO (Ptr String)

-- | Adds a byte onto the start of a t'GI.GLib.Structs.String.String',
-- expanding it if necessary.
stringPrependC ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> Int8
    -- ^ /@c@/: the byte to prepend on the start of the t'GI.GLib.Structs.String.String'
    -> m String
    -- ^ __Returns:__ /@string@/
stringPrependC :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int8 -> m String
stringPrependC String
string Int8
c = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_prepend_c string' c
    checkUnexpectedReturnNULL "stringPrependC" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringPrependCMethodInfo
instance (signature ~ (Int8 -> m String), MonadIO m) => O.OverloadedMethod StringPrependCMethodInfo String signature where
    overloadedMethod = stringPrependC

instance O.OverloadedMethodInfo StringPrependCMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringPrependC",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringPrependC"
        })


#endif

-- method String::prepend_len
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "val"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "bytes to prepend" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TSSize
--           , argCType = Just "gssize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "number of bytes in @val to prepend, or -1 for all of @val"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_prepend_len" g_string_prepend_len :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- val : TBasicType TUTF8
    DI.Int64 ->                             -- len : TBasicType TSSize
    IO (Ptr String)

-- | Prepends /@len@/ bytes of /@val@/ to /@string@/.
-- 
-- If /@len@/ is positive, /@val@/ may contain embedded nuls and need
-- not be nul-terminated. It is the caller\'s responsibility to
-- ensure that /@val@/ has at least /@len@/ addressable bytes.
-- 
-- If /@len@/ is negative, /@val@/ must be nul-terminated and /@len@/
-- is considered to request the entire string length. This
-- makes 'GI.GLib.Structs.String.stringPrependLen' equivalent to 'GI.GLib.Structs.String.stringPrepend'.
stringPrependLen ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> T.Text
    -- ^ /@val@/: bytes to prepend
    -> DI.Int64
    -- ^ /@len@/: number of bytes in /@val@/ to prepend, or -1 for all of /@val@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringPrependLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Int64 -> m String
stringPrependLen String
string Text
val Int64
len = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    val' <- textToCString val
    result <- g_string_prepend_len string' val' len
    checkUnexpectedReturnNULL "stringPrependLen" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    freeMem val'
    return result'

#if defined(ENABLE_OVERLOADING)
data StringPrependLenMethodInfo
instance (signature ~ (T.Text -> DI.Int64 -> m String), MonadIO m) => O.OverloadedMethod StringPrependLenMethodInfo String signature where
    overloadedMethod = stringPrependLen

instance O.OverloadedMethodInfo StringPrependLenMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringPrependLen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringPrependLen"
        })


#endif

-- method String::prepend_unichar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wc"
--           , argType = TBasicType TUniChar
--           , argCType = Just "gunichar"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a Unicode character"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_prepend_unichar" g_string_prepend_unichar :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CInt ->                                 -- wc : TBasicType TUniChar
    IO (Ptr String)

-- | Converts a Unicode character into UTF-8, and prepends it
-- to the string.
stringPrependUnichar ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> Char
    -- ^ /@wc@/: a Unicode character
    -> m String
    -- ^ __Returns:__ /@string@/
stringPrependUnichar :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Char -> m String
stringPrependUnichar String
string Char
wc = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    let wc' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
SP.ord) Char
wc
    result <- g_string_prepend_unichar string' wc'
    checkUnexpectedReturnNULL "stringPrependUnichar" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringPrependUnicharMethodInfo
instance (signature ~ (Char -> m String), MonadIO m) => O.OverloadedMethod StringPrependUnicharMethodInfo String signature where
    overloadedMethod = stringPrependUnichar

instance O.OverloadedMethodInfo StringPrependUnicharMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringPrependUnichar",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringPrependUnichar"
        })


#endif

-- method String::replace
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "find"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string to find in @string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "replace"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string to insert in place of @find"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "limit"
--           , argType = TBasicType TUInt
--           , argCType = Just "guint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the maximum instances of @find to replace with @replace, or `0` for\nno limit"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_string_replace" g_string_replace :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- find : TBasicType TUTF8
    CString ->                              -- replace : TBasicType TUTF8
    Word32 ->                               -- limit : TBasicType TUInt
    IO Word32

-- | Replaces the string /@find@/ with the string /@replace@/ in a t'GI.GLib.Structs.String.String' up to
-- /@limit@/ times. If the number of instances of /@find@/ in the t'GI.GLib.Structs.String.String' is
-- less than /@limit@/, all instances are replaced. If /@limit@/ is @0@,
-- all instances of /@find@/ are replaced.
-- 
-- If /@find@/ is the empty string, since versions 2.69.1 and 2.68.4 the
-- replacement will be inserted no more than once per possible position
-- (beginning of string, end of string and between characters). This did
-- not work correctly in earlier versions.
-- 
-- If /@limit@/ is zero and more than @G_MAXUINT@ instances of /@find@/ are in
-- the input string, they will all be replaced, but the return value will
-- be capped at @G_MAXUINT@.
-- 
-- /Since: 2.68/
stringReplace ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> T.Text
    -- ^ /@find@/: the string to find in /@string@/
    -> T.Text
    -- ^ /@replace@/: the string to insert in place of /@find@/
    -> Word32
    -- ^ /@limit@/: the maximum instances of /@find@/ to replace with /@replace@/, or @0@ for
    -- no limit
    -> m Word32
    -- ^ __Returns:__ the number of find and replace operations performed,
    --   up to @G_MAXUINT@
stringReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Text -> Word32 -> m Word32
stringReplace String
string Text
find Text
replace Word32
limit = 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
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    find' <- textToCString find
    replace' <- textToCString replace
    result <- g_string_replace string' find' replace' limit
    touchManagedPtr string
    freeMem find'
    freeMem replace'
    return result

#if defined(ENABLE_OVERLOADING)
data StringReplaceMethodInfo
instance (signature ~ (T.Text -> T.Text -> Word32 -> m Word32), MonadIO m) => O.OverloadedMethod StringReplaceMethodInfo String signature where
    overloadedMethod = stringReplace

instance O.OverloadedMethodInfo StringReplaceMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringReplace",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringReplace"
        })


#endif

-- method String::set_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new length" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_set_size" g_string_set_size :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    FCT.CSize ->                            -- len : TBasicType TSize
    IO (Ptr String)

-- | Sets the length of a t'GI.GLib.Structs.String.String'. If the length is less than
-- the current length, the string will be truncated. If the
-- length is greater than the current length, the contents
-- of the newly added area are undefined. (However, as
-- always, string->str[string->len] will be a nul byte.)
stringSetSize ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> FCT.CSize
    -- ^ /@len@/: the new length
    -> m String
    -- ^ __Returns:__ /@string@/
stringSetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> CSize -> m String
stringSetSize String
string CSize
len = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_set_size string' len
    checkUnexpectedReturnNULL "stringSetSize" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringSetSizeMethodInfo
instance (signature ~ (FCT.CSize -> m String), MonadIO m) => O.OverloadedMethod StringSetSizeMethodInfo String signature where
    overloadedMethod = stringSetSize

instance O.OverloadedMethodInfo StringSetSizeMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringSetSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringSetSize"
        })


#endif

-- method String::truncate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TSize
--           , argCType = Just "gsize"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new size of @string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_truncate" g_string_truncate :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    FCT.CSize ->                            -- len : TBasicType TSize
    IO (Ptr String)

-- | Cuts off the end of the GString, leaving the first /@len@/ bytes.
stringTruncate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> FCT.CSize
    -- ^ /@len@/: the new size of /@string@/
    -> m String
    -- ^ __Returns:__ /@string@/
stringTruncate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> CSize -> m String
stringTruncate String
string CSize
len = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_truncate string' len
    checkUnexpectedReturnNULL "stringTruncate" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringTruncateMethodInfo
instance (signature ~ (FCT.CSize -> m String), MonadIO m) => O.OverloadedMethod StringTruncateMethodInfo String signature where
    overloadedMethod = stringTruncate

instance O.OverloadedMethodInfo StringTruncateMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringTruncate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringTruncate"
        })


#endif

-- method String::up
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , argCType = Just "GString*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GString" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "String" })
-- throws : False
-- Skip return : False

foreign import ccall "g_string_up" g_string_up :: 
    Ptr String ->                           -- string : TInterface (Name {namespace = "GLib", name = "String"})
    IO (Ptr String)

{-# DEPRECATED stringUp ["(Since version 2.2)","This function uses the locale-specific","    @/toupper()/@ function, which is almost never the right thing.","    Use 'GI.GLib.Structs.String.stringAsciiUp' or 'GI.GLib.Functions.utf8Strup' instead."] #-}
-- | Converts a t'GI.GLib.Structs.String.String' to uppercase.
stringUp ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String'
    -> m String
    -- ^ __Returns:__ /@string@/
stringUp :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringUp String
string = IO String -> m String
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> m String) -> IO String -> m String
forall a b. (a -> b) -> a -> b
$ do
    string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    result <- g_string_up string'
    checkUnexpectedReturnNULL "stringUp" result
    result' <- (newBoxed String) result
    touchManagedPtr string
    return result'

#if defined(ENABLE_OVERLOADING)
data StringUpMethodInfo
instance (signature ~ (m String), MonadIO m) => O.OverloadedMethod StringUpMethodInfo String signature where
    overloadedMethod = stringUp

instance O.OverloadedMethodInfo StringUpMethodInfo String where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.String.stringUp",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.30/docs/GI-GLib-Structs-String.html#v:stringUp"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveStringMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveStringMethod "append" o = StringAppendMethodInfo
    ResolveStringMethod "appendC" o = StringAppendCMethodInfo
    ResolveStringMethod "appendLen" o = StringAppendLenMethodInfo
    ResolveStringMethod "appendUnichar" o = StringAppendUnicharMethodInfo
    ResolveStringMethod "appendUriEscaped" o = StringAppendUriEscapedMethodInfo
    ResolveStringMethod "asciiDown" o = StringAsciiDownMethodInfo
    ResolveStringMethod "asciiUp" o = StringAsciiUpMethodInfo
    ResolveStringMethod "assign" o = StringAssignMethodInfo
    ResolveStringMethod "copy" o = StringCopyMethodInfo
    ResolveStringMethod "down" o = StringDownMethodInfo
    ResolveStringMethod "equal" o = StringEqualMethodInfo
    ResolveStringMethod "erase" o = StringEraseMethodInfo
    ResolveStringMethod "free" o = StringFreeMethodInfo
    ResolveStringMethod "freeAndSteal" o = StringFreeAndStealMethodInfo
    ResolveStringMethod "freeToBytes" o = StringFreeToBytesMethodInfo
    ResolveStringMethod "hash" o = StringHashMethodInfo
    ResolveStringMethod "insert" o = StringInsertMethodInfo
    ResolveStringMethod "insertC" o = StringInsertCMethodInfo
    ResolveStringMethod "insertLen" o = StringInsertLenMethodInfo
    ResolveStringMethod "insertUnichar" o = StringInsertUnicharMethodInfo
    ResolveStringMethod "overwrite" o = StringOverwriteMethodInfo
    ResolveStringMethod "overwriteLen" o = StringOverwriteLenMethodInfo
    ResolveStringMethod "prepend" o = StringPrependMethodInfo
    ResolveStringMethod "prependC" o = StringPrependCMethodInfo
    ResolveStringMethod "prependLen" o = StringPrependLenMethodInfo
    ResolveStringMethod "prependUnichar" o = StringPrependUnicharMethodInfo
    ResolveStringMethod "replace" o = StringReplaceMethodInfo
    ResolveStringMethod "truncate" o = StringTruncateMethodInfo
    ResolveStringMethod "up" o = StringUpMethodInfo
    ResolveStringMethod "setSize" o = StringSetSizeMethodInfo
    ResolveStringMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif