{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.String
(
String(..) ,
newZeroString ,
#if defined(ENABLE_OVERLOADING)
ResolveStringMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
StringAppendMethodInfo ,
#endif
stringAppend ,
#if defined(ENABLE_OVERLOADING)
StringAppendCMethodInfo ,
#endif
stringAppendC ,
#if defined(ENABLE_OVERLOADING)
StringAppendLenMethodInfo ,
#endif
stringAppendLen ,
#if defined(ENABLE_OVERLOADING)
StringAppendUnicharMethodInfo ,
#endif
stringAppendUnichar ,
#if defined(ENABLE_OVERLOADING)
StringAppendUriEscapedMethodInfo ,
#endif
stringAppendUriEscaped ,
#if defined(ENABLE_OVERLOADING)
StringAsciiDownMethodInfo ,
#endif
stringAsciiDown ,
#if defined(ENABLE_OVERLOADING)
StringAsciiUpMethodInfo ,
#endif
stringAsciiUp ,
#if defined(ENABLE_OVERLOADING)
StringAssignMethodInfo ,
#endif
stringAssign ,
#if defined(ENABLE_OVERLOADING)
StringDownMethodInfo ,
#endif
stringDown ,
#if defined(ENABLE_OVERLOADING)
StringEqualMethodInfo ,
#endif
stringEqual ,
#if defined(ENABLE_OVERLOADING)
StringEraseMethodInfo ,
#endif
stringErase ,
#if defined(ENABLE_OVERLOADING)
StringFreeMethodInfo ,
#endif
stringFree ,
#if defined(ENABLE_OVERLOADING)
StringFreeAndStealMethodInfo ,
#endif
stringFreeAndSteal ,
#if defined(ENABLE_OVERLOADING)
StringFreeToBytesMethodInfo ,
#endif
stringFreeToBytes ,
#if defined(ENABLE_OVERLOADING)
StringHashMethodInfo ,
#endif
stringHash ,
#if defined(ENABLE_OVERLOADING)
StringInsertMethodInfo ,
#endif
stringInsert ,
#if defined(ENABLE_OVERLOADING)
StringInsertCMethodInfo ,
#endif
stringInsertC ,
#if defined(ENABLE_OVERLOADING)
StringInsertLenMethodInfo ,
#endif
stringInsertLen ,
#if defined(ENABLE_OVERLOADING)
StringInsertUnicharMethodInfo ,
#endif
stringInsertUnichar ,
stringNew ,
stringNewLen ,
#if defined(ENABLE_OVERLOADING)
StringOverwriteMethodInfo ,
#endif
stringOverwrite ,
#if defined(ENABLE_OVERLOADING)
StringOverwriteLenMethodInfo ,
#endif
stringOverwriteLen ,
#if defined(ENABLE_OVERLOADING)
StringPrependMethodInfo ,
#endif
stringPrepend ,
#if defined(ENABLE_OVERLOADING)
StringPrependCMethodInfo ,
#endif
stringPrependC ,
#if defined(ENABLE_OVERLOADING)
StringPrependLenMethodInfo ,
#endif
stringPrependLen ,
#if defined(ENABLE_OVERLOADING)
StringPrependUnicharMethodInfo ,
#endif
stringPrependUnichar ,
#if defined(ENABLE_OVERLOADING)
StringReplaceMethodInfo ,
#endif
stringReplace ,
#if defined(ENABLE_OVERLOADING)
StringSetSizeMethodInfo ,
#endif
stringSetSize ,
stringSizedNew ,
#if defined(ENABLE_OVERLOADING)
StringTruncateMethodInfo ,
#endif
stringTruncate ,
#if defined(ENABLE_OVERLOADING)
StringUpMethodInfo ,
#endif
stringUp ,
getStringAllocatedLen ,
setStringAllocatedLen ,
#if defined(ENABLE_OVERLOADING)
string_allocatedLen ,
#endif
getStringLen ,
setStringLen ,
#if defined(ENABLE_OVERLOADING)
string_len ,
#endif
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 {-# SOURCE #-} qualified GI.GLib.Structs.Bytes as GLib.Bytes
newtype String = String (SP.ManagedPtr String)
deriving (String -> String -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: String -> String -> Bool
$c/= :: String -> String -> Bool
== :: String -> String -> Bool
$c== :: 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
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 = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr String)
gvalueSet_ Ptr GValue
gv (P.Just String
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr String
obj (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 String
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr String)
if Ptr String
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr String -> String
String Ptr String
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
newZeroString :: MonadIO m => m String
newZeroString :: forall (m :: * -> *). MonadIO m => m String
newZeroString = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
24 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 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
String
o <- forall (m :: * -> *). MonadIO m => m String
newZeroString
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set String
o [AttrOp String tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return String
o
getStringStr :: MonadIO m => String -> m (Maybe T.Text)
getStringStr :: forall (m :: * -> *). MonadIO m => String -> m (Maybe Text)
getStringStr String
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr String
s forall a b. (a -> b) -> a -> b
$ \Ptr String
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr String
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setStringStr :: MonadIO m => String -> CString -> m ()
setStringStr :: forall (m :: * -> *). MonadIO m => String -> CString -> m ()
setStringStr String
s CString
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr String
s forall a b. (a -> b) -> a -> b
$ \Ptr String
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr String
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)
clearStringStr :: MonadIO m => String -> m ()
clearStringStr :: forall (m :: * -> *). MonadIO m => String -> m ()
clearStringStr String
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr String
s forall a b. (a -> b) -> a -> b
$ \Ptr String
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr String
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (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.27/docs/GI-GLib-Structs-String.html#g:attr:str"
})
string_str :: AttrLabelProxy "str"
string_str = AttrLabelProxy
#endif
getStringLen :: MonadIO m => String -> m Word64
getStringLen :: forall (m :: * -> *). MonadIO m => String -> m Word64
getStringLen String
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr String
s forall a b. (a -> b) -> a -> b
$ \Ptr String
ptr -> do
Word64
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr String
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setStringLen :: MonadIO m => String -> Word64 -> m ()
setStringLen :: forall (m :: * -> *). MonadIO m => String -> Word64 -> m ()
setStringLen String
s Word64
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr String
s forall a b. (a -> b) -> a -> b
$ \Ptr String
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr String
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data StringLenFieldInfo
instance AttrInfo StringLenFieldInfo where
type AttrBaseTypeConstraint StringLenFieldInfo = (~) String
type AttrAllowedOps StringLenFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint StringLenFieldInfo = (~) Word64
type AttrTransferTypeConstraint StringLenFieldInfo = (~)Word64
type AttrTransferType StringLenFieldInfo = Word64
type AttrGetType StringLenFieldInfo = Word64
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.27/docs/GI-GLib-Structs-String.html#g:attr:len"
})
string_len :: AttrLabelProxy "len"
string_len = AttrLabelProxy
#endif
getStringAllocatedLen :: MonadIO m => String -> m Word64
getStringAllocatedLen :: forall (m :: * -> *). MonadIO m => String -> m Word64
getStringAllocatedLen String
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr String
s forall a b. (a -> b) -> a -> b
$ \Ptr String
ptr -> do
Word64
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr String
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setStringAllocatedLen :: MonadIO m => String -> Word64 -> m ()
setStringAllocatedLen :: forall (m :: * -> *). MonadIO m => String -> Word64 -> m ()
setStringAllocatedLen String
s Word64
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr String
s forall a b. (a -> b) -> a -> b
$ \Ptr String
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr String
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data StringAllocatedLenFieldInfo
instance AttrInfo StringAllocatedLenFieldInfo where
type AttrBaseTypeConstraint StringAllocatedLenFieldInfo = (~) String
type AttrAllowedOps StringAllocatedLenFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint StringAllocatedLenFieldInfo = (~) Word64
type AttrTransferTypeConstraint StringAllocatedLenFieldInfo = (~)Word64
type AttrTransferType StringAllocatedLenFieldInfo = Word64
type AttrGetType StringAllocatedLenFieldInfo = Word64
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.27/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
foreign import ccall "g_string_new" g_string_new ::
CString ->
IO (Ptr String)
stringNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m String
stringNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m String
stringNew Maybe Text
init = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
maybeInit <- case Maybe Text
init of
Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just Text
jInit -> do
CString
jInit' <- Text -> IO CString
textToCString Text
jInit
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jInit'
Ptr String
result <- CString -> IO (Ptr String)
g_string_new CString
maybeInit
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringNew" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. Ptr a -> IO ()
freeMem CString
maybeInit
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_string_new_len" g_string_new_len ::
CString ->
Int64 ->
IO (Ptr String)
stringNewLen ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int64
-> m String
stringNewLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Int64 -> m String
stringNewLen Text
init Int64
len = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
init' <- Text -> IO CString
textToCString Text
init
Ptr String
result <- CString -> Int64 -> IO (Ptr String)
g_string_new_len CString
init' Int64
len
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringNewLen" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. Ptr a -> IO ()
freeMem CString
init'
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_string_sized_new" g_string_sized_new ::
Word64 ->
IO (Ptr String)
stringSizedNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word64
-> m String
stringSizedNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word64 -> m String
stringSizedNew Word64
dflSize = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
result <- Word64 -> IO (Ptr String)
g_string_sized_new Word64
dflSize
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringSizedNew" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr String -> String
String) Ptr String
result
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_string_append" g_string_append ::
Ptr String ->
CString ->
IO (Ptr String)
stringAppend ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> T.Text
-> m String
stringAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> m String
stringAppend String
string Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
val' <- Text -> IO CString
textToCString Text
val
Ptr String
result <- Ptr String -> CString -> IO (Ptr String)
g_string_append Ptr String
string' CString
val'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringAppend" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringAppend"
})
#endif
foreign import ccall "g_string_append_c" g_string_append_c ::
Ptr String ->
Int8 ->
IO (Ptr String)
stringAppendC ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Int8
-> m String
stringAppendC :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int8 -> m String
stringAppendC String
string Int8
c = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> Int8 -> IO (Ptr String)
g_string_append_c Ptr String
string' Int8
c
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringAppendC" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringAppendC"
})
#endif
foreign import ccall "g_string_append_len" g_string_append_len ::
Ptr String ->
CString ->
Int64 ->
IO (Ptr String)
stringAppendLen ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> T.Text
-> Int64
-> m String
stringAppendLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Int64 -> m String
stringAppendLen String
string Text
val Int64
len = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
val' <- Text -> IO CString
textToCString Text
val
Ptr String
result <- Ptr String -> CString -> Int64 -> IO (Ptr String)
g_string_append_len Ptr String
string' CString
val' Int64
len
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringAppendLen" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringAppendLenMethodInfo
instance (signature ~ (T.Text -> 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.27/docs/GI-GLib-Structs-String.html#v:stringAppendLen"
})
#endif
foreign import ccall "g_string_append_unichar" g_string_append_unichar ::
Ptr String ->
CInt ->
IO (Ptr String)
stringAppendUnichar ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Char
-> m String
stringAppendUnichar :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Char -> m String
stringAppendUnichar String
string Char
wc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
let wc' :: CInt
wc' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
SP.ord) Char
wc
Ptr String
result <- Ptr String -> CInt -> IO (Ptr String)
g_string_append_unichar Ptr String
string' CInt
wc'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringAppendUnichar" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringAppendUnichar"
})
#endif
foreign import ccall "g_string_append_uri_escaped" g_string_append_uri_escaped ::
Ptr String ->
CString ->
CString ->
CInt ->
IO (Ptr String)
stringAppendUriEscaped ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> T.Text
-> T.Text
-> Bool
-> m String
stringAppendUriEscaped :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Text -> Bool -> m String
stringAppendUriEscaped String
string Text
unescaped Text
reservedCharsAllowed Bool
allowUtf8 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
unescaped' <- Text -> IO CString
textToCString Text
unescaped
CString
reservedCharsAllowed' <- Text -> IO CString
textToCString Text
reservedCharsAllowed
let allowUtf8' :: CInt
allowUtf8' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
allowUtf8
Ptr String
result <- Ptr String -> CString -> CString -> CInt -> IO (Ptr String)
g_string_append_uri_escaped Ptr String
string' CString
unescaped' CString
reservedCharsAllowed' CInt
allowUtf8'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringAppendUriEscaped" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
unescaped'
forall a. Ptr a -> IO ()
freeMem CString
reservedCharsAllowed'
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringAppendUriEscaped"
})
#endif
foreign import ccall "g_string_ascii_down" g_string_ascii_down ::
Ptr String ->
IO (Ptr String)
stringAsciiDown ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> m String
stringAsciiDown :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringAsciiDown String
string = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> IO (Ptr String)
g_string_ascii_down Ptr String
string'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringAsciiDown" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringAsciiDown"
})
#endif
foreign import ccall "g_string_ascii_up" g_string_ascii_up ::
Ptr String ->
IO (Ptr String)
stringAsciiUp ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> m String
stringAsciiUp :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringAsciiUp String
string = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> IO (Ptr String)
g_string_ascii_up Ptr String
string'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringAsciiUp" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringAsciiUp"
})
#endif
foreign import ccall "g_string_assign" g_string_assign ::
Ptr String ->
CString ->
IO (Ptr String)
stringAssign ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> T.Text
-> m String
stringAssign :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> m String
stringAssign String
string Text
rval = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
rval' <- Text -> IO CString
textToCString Text
rval
Ptr String
result <- Ptr String -> CString -> IO (Ptr String)
g_string_assign Ptr String
string' CString
rval'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringAssign" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
rval'
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringAssign"
})
#endif
foreign import ccall "g_string_down" g_string_down ::
Ptr 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."] #-}
stringDown ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> m String
stringDown :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringDown String
string = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> IO (Ptr String)
g_string_down Ptr String
string'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringDown" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringDown"
})
#endif
foreign import ccall "g_string_equal" g_string_equal ::
Ptr String ->
Ptr String ->
IO CInt
stringEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> String
-> m Bool
stringEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> String -> m Bool
stringEqual String
v String
v2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
v' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
v
Ptr String
v2' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
v2
CInt
result <- Ptr String -> Ptr String -> IO CInt
g_string_equal Ptr String
v' Ptr String
v2'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
v
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
v2
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
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.27/docs/GI-GLib-Structs-String.html#v:stringEqual"
})
#endif
foreign import ccall "g_string_erase" g_string_erase ::
Ptr String ->
Int64 ->
Int64 ->
IO (Ptr String)
stringErase ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Int64
-> Int64
-> m String
stringErase :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Int64 -> m String
stringErase String
string Int64
pos Int64
len = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> Int64 -> Int64 -> IO (Ptr String)
g_string_erase Ptr String
string' Int64
pos Int64
len
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringErase" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringEraseMethodInfo
instance (signature ~ (Int64 -> 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.27/docs/GI-GLib-Structs-String.html#v:stringErase"
})
#endif
foreign import ccall "g_string_free" g_string_free ::
Ptr String ->
CInt ->
IO CString
stringFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Bool
-> m (Maybe T.Text)
stringFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Bool -> m (Maybe Text)
stringFree String
string Bool
freeSegment = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed String
string
let freeSegment' :: CInt
freeSegment' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
freeSegment
CString
result <- Ptr String -> CInt -> IO CString
g_string_free Ptr String
string' CInt
freeSegment'
Maybe Text
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall a. Ptr a -> IO ()
freeMem CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
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.27/docs/GI-GLib-Structs-String.html#v:stringFree"
})
#endif
foreign import ccall "g_string_free_and_steal" g_string_free_and_steal ::
Ptr String ->
IO CString
stringFreeAndSteal ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> m T.Text
stringFreeAndSteal :: forall (m :: * -> *). (HasCallStack, MonadIO m) => String -> m Text
stringFreeAndSteal String
string = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed String
string
CString
result <- Ptr String -> IO CString
g_string_free_and_steal Ptr String
string'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringFreeAndSteal" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return Text
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.27/docs/GI-GLib-Structs-String.html#v:stringFreeAndSteal"
})
#endif
foreign import ccall "g_string_free_to_bytes" g_string_free_to_bytes ::
Ptr String ->
IO (Ptr GLib.Bytes.Bytes)
stringFreeToBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> m GLib.Bytes.Bytes
stringFreeToBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m Bytes
stringFreeToBytes String
string = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed String
string
Ptr Bytes
result <- Ptr String -> IO (Ptr Bytes)
g_string_free_to_bytes Ptr String
string'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringFreeToBytes" Ptr Bytes
result
Bytes
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
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.27/docs/GI-GLib-Structs-String.html#v:stringFreeToBytes"
})
#endif
foreign import ccall "g_string_hash" g_string_hash ::
Ptr String ->
IO Word32
stringHash ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> m Word32
stringHash :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m Word32
stringHash String
str = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
str' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
str
Word32
result <- Ptr String -> IO Word32
g_string_hash Ptr String
str'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
str
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
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.27/docs/GI-GLib-Structs-String.html#v:stringHash"
})
#endif
foreign import ccall "g_string_insert" g_string_insert ::
Ptr String ->
Int64 ->
CString ->
IO (Ptr String)
stringInsert ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Int64
-> T.Text
-> m String
stringInsert :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Text -> m String
stringInsert String
string Int64
pos Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
val' <- Text -> IO CString
textToCString Text
val
Ptr String
result <- Ptr String -> Int64 -> CString -> IO (Ptr String)
g_string_insert Ptr String
string' Int64
pos CString
val'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringInsert" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringInsertMethodInfo
instance (signature ~ (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.27/docs/GI-GLib-Structs-String.html#v:stringInsert"
})
#endif
foreign import ccall "g_string_insert_c" g_string_insert_c ::
Ptr String ->
Int64 ->
Int8 ->
IO (Ptr String)
stringInsertC ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Int64
-> Int8
-> m String
stringInsertC :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Int8 -> m String
stringInsertC String
string Int64
pos Int8
c = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> Int64 -> Int8 -> IO (Ptr String)
g_string_insert_c Ptr String
string' Int64
pos Int8
c
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringInsertC" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringInsertCMethodInfo
instance (signature ~ (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.27/docs/GI-GLib-Structs-String.html#v:stringInsertC"
})
#endif
foreign import ccall "g_string_insert_len" g_string_insert_len ::
Ptr String ->
Int64 ->
CString ->
Int64 ->
IO (Ptr String)
stringInsertLen ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Int64
-> T.Text
-> Int64
-> m String
stringInsertLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Text -> Int64 -> m String
stringInsertLen String
string Int64
pos Text
val Int64
len = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
val' <- Text -> IO CString
textToCString Text
val
Ptr String
result <- Ptr String -> Int64 -> CString -> Int64 -> IO (Ptr String)
g_string_insert_len Ptr String
string' Int64
pos CString
val' Int64
len
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringInsertLen" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringInsertLenMethodInfo
instance (signature ~ (Int64 -> T.Text -> 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.27/docs/GI-GLib-Structs-String.html#v:stringInsertLen"
})
#endif
foreign import ccall "g_string_insert_unichar" g_string_insert_unichar ::
Ptr String ->
Int64 ->
CInt ->
IO (Ptr String)
stringInsertUnichar ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Int64
-> Char
-> m String
stringInsertUnichar :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int64 -> Char -> m String
stringInsertUnichar String
string Int64
pos Char
wc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
let wc' :: CInt
wc' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
SP.ord) Char
wc
Ptr String
result <- Ptr String -> Int64 -> CInt -> IO (Ptr String)
g_string_insert_unichar Ptr String
string' Int64
pos CInt
wc'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringInsertUnichar" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringInsertUnicharMethodInfo
instance (signature ~ (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.27/docs/GI-GLib-Structs-String.html#v:stringInsertUnichar"
})
#endif
foreign import ccall "g_string_overwrite" g_string_overwrite ::
Ptr String ->
Word64 ->
CString ->
IO (Ptr String)
stringOverwrite ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Word64
-> T.Text
-> m String
stringOverwrite :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Word64 -> Text -> m String
stringOverwrite String
string Word64
pos Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
val' <- Text -> IO CString
textToCString Text
val
Ptr String
result <- Ptr String -> Word64 -> CString -> IO (Ptr String)
g_string_overwrite Ptr String
string' Word64
pos CString
val'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringOverwrite" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringOverwriteMethodInfo
instance (signature ~ (Word64 -> 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.27/docs/GI-GLib-Structs-String.html#v:stringOverwrite"
})
#endif
foreign import ccall "g_string_overwrite_len" g_string_overwrite_len ::
Ptr String ->
Word64 ->
CString ->
Int64 ->
IO (Ptr String)
stringOverwriteLen ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Word64
-> T.Text
-> Int64
-> m String
stringOverwriteLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Word64 -> Text -> Int64 -> m String
stringOverwriteLen String
string Word64
pos Text
val Int64
len = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
val' <- Text -> IO CString
textToCString Text
val
Ptr String
result <- Ptr String -> Word64 -> CString -> Int64 -> IO (Ptr String)
g_string_overwrite_len Ptr String
string' Word64
pos CString
val' Int64
len
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringOverwriteLen" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringOverwriteLenMethodInfo
instance (signature ~ (Word64 -> T.Text -> 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.27/docs/GI-GLib-Structs-String.html#v:stringOverwriteLen"
})
#endif
foreign import ccall "g_string_prepend" g_string_prepend ::
Ptr String ->
CString ->
IO (Ptr String)
stringPrepend ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> T.Text
-> m String
stringPrepend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> m String
stringPrepend String
string Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
val' <- Text -> IO CString
textToCString Text
val
Ptr String
result <- Ptr String -> CString -> IO (Ptr String)
g_string_prepend Ptr String
string' CString
val'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringPrepend" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringPrepend"
})
#endif
foreign import ccall "g_string_prepend_c" g_string_prepend_c ::
Ptr String ->
Int8 ->
IO (Ptr String)
stringPrependC ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Int8
-> m String
stringPrependC :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Int8 -> m String
stringPrependC String
string Int8
c = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> Int8 -> IO (Ptr String)
g_string_prepend_c Ptr String
string' Int8
c
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringPrependC" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringPrependC"
})
#endif
foreign import ccall "g_string_prepend_len" g_string_prepend_len ::
Ptr String ->
CString ->
Int64 ->
IO (Ptr String)
stringPrependLen ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> T.Text
-> Int64
-> m String
stringPrependLen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Int64 -> m String
stringPrependLen String
string Text
val Int64
len = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
val' <- Text -> IO CString
textToCString Text
val
Ptr String
result <- Ptr String -> CString -> Int64 -> IO (Ptr String)
g_string_prepend_len Ptr String
string' CString
val' Int64
len
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringPrependLen" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringPrependLenMethodInfo
instance (signature ~ (T.Text -> 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.27/docs/GI-GLib-Structs-String.html#v:stringPrependLen"
})
#endif
foreign import ccall "g_string_prepend_unichar" g_string_prepend_unichar ::
Ptr String ->
CInt ->
IO (Ptr String)
stringPrependUnichar ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Char
-> m String
stringPrependUnichar :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Char -> m String
stringPrependUnichar String
string Char
wc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
let wc' :: CInt
wc' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
SP.ord) Char
wc
Ptr String
result <- Ptr String -> CInt -> IO (Ptr String)
g_string_prepend_unichar Ptr String
string' CInt
wc'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringPrependUnichar" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/docs/GI-GLib-Structs-String.html#v:stringPrependUnichar"
})
#endif
foreign import ccall "g_string_replace" g_string_replace ::
Ptr String ->
CString ->
CString ->
Word32 ->
IO Word32
stringReplace ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> T.Text
-> T.Text
-> Word32
-> m Word32
stringReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Text -> Word32 -> m Word32
stringReplace String
string Text
find Text
replace Word32
limit = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
CString
find' <- Text -> IO CString
textToCString Text
find
CString
replace' <- Text -> IO CString
textToCString Text
replace
Word32
result <- Ptr String -> CString -> CString -> Word32 -> IO Word32
g_string_replace Ptr String
string' CString
find' CString
replace' Word32
limit
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall a. Ptr a -> IO ()
freeMem CString
find'
forall a. Ptr a -> IO ()
freeMem CString
replace'
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
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.27/docs/GI-GLib-Structs-String.html#v:stringReplace"
})
#endif
foreign import ccall "g_string_set_size" g_string_set_size ::
Ptr String ->
Word64 ->
IO (Ptr String)
stringSetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Word64
-> m String
stringSetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Word64 -> m String
stringSetSize String
string Word64
len = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> Word64 -> IO (Ptr String)
g_string_set_size Ptr String
string' Word64
len
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringSetSize" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringSetSizeMethodInfo
instance (signature ~ (Word64 -> 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.27/docs/GI-GLib-Structs-String.html#v:stringSetSize"
})
#endif
foreign import ccall "g_string_truncate" g_string_truncate ::
Ptr String ->
Word64 ->
IO (Ptr String)
stringTruncate ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> Word64
-> m String
stringTruncate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Word64 -> m String
stringTruncate String
string Word64
len = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> Word64 -> IO (Ptr String)
g_string_truncate Ptr String
string' Word64
len
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringTruncate" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
result'
#if defined(ENABLE_OVERLOADING)
data StringTruncateMethodInfo
instance (signature ~ (Word64 -> 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.27/docs/GI-GLib-Structs-String.html#v:stringTruncate"
})
#endif
foreign import ccall "g_string_up" g_string_up ::
Ptr 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."] #-}
stringUp ::
(B.CallStack.HasCallStack, MonadIO m) =>
String
-> m String
stringUp :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> m String
stringUp String
string = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr String
string' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
Ptr String
result <- Ptr String -> IO (Ptr String)
g_string_up Ptr String
string'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"stringUp" Ptr String
result
String
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr String -> String
String) Ptr String
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
forall (m :: * -> *) a. Monad m => a -> m a
return String
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.27/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 "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