{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.VariantType
(
VariantType(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveVariantTypeMethod ,
#endif
variantTypeChecked_ ,
#if defined(ENABLE_OVERLOADING)
VariantTypeCopyMethodInfo ,
#endif
variantTypeCopy ,
#if defined(ENABLE_OVERLOADING)
VariantTypeDupStringMethodInfo ,
#endif
variantTypeDupString ,
#if defined(ENABLE_OVERLOADING)
VariantTypeElementMethodInfo ,
#endif
variantTypeElement ,
#if defined(ENABLE_OVERLOADING)
VariantTypeEqualMethodInfo ,
#endif
variantTypeEqual ,
#if defined(ENABLE_OVERLOADING)
VariantTypeFirstMethodInfo ,
#endif
variantTypeFirst ,
#if defined(ENABLE_OVERLOADING)
VariantTypeFreeMethodInfo ,
#endif
variantTypeFree ,
#if defined(ENABLE_OVERLOADING)
VariantTypeGetStringLengthMethodInfo ,
#endif
variantTypeGetStringLength ,
#if defined(ENABLE_OVERLOADING)
VariantTypeHashMethodInfo ,
#endif
variantTypeHash ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsArrayMethodInfo ,
#endif
variantTypeIsArray ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsBasicMethodInfo ,
#endif
variantTypeIsBasic ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsContainerMethodInfo ,
#endif
variantTypeIsContainer ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsDefiniteMethodInfo ,
#endif
variantTypeIsDefinite ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsDictEntryMethodInfo ,
#endif
variantTypeIsDictEntry ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsMaybeMethodInfo ,
#endif
variantTypeIsMaybe ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsSubtypeOfMethodInfo ,
#endif
variantTypeIsSubtypeOf ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsTupleMethodInfo ,
#endif
variantTypeIsTuple ,
#if defined(ENABLE_OVERLOADING)
VariantTypeIsVariantMethodInfo ,
#endif
variantTypeIsVariant ,
#if defined(ENABLE_OVERLOADING)
VariantTypeKeyMethodInfo ,
#endif
variantTypeKey ,
#if defined(ENABLE_OVERLOADING)
VariantTypeNItemsMethodInfo ,
#endif
variantTypeNItems ,
variantTypeNew ,
variantTypeNewArray ,
variantTypeNewDictEntry ,
variantTypeNewMaybe ,
variantTypeNewTuple ,
#if defined(ENABLE_OVERLOADING)
VariantTypeNextMethodInfo ,
#endif
variantTypeNext ,
variantTypeStringGetDepth_ ,
variantTypeStringIsValid ,
variantTypeStringScan ,
#if defined(ENABLE_OVERLOADING)
VariantTypeValueMethodInfo ,
#endif
variantTypeValue ,
) 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 Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
#else
#endif
newtype VariantType = VariantType (SP.ManagedPtr VariantType)
deriving (VariantType -> VariantType -> Bool
(VariantType -> VariantType -> Bool)
-> (VariantType -> VariantType -> Bool) -> Eq VariantType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariantType -> VariantType -> Bool
== :: VariantType -> VariantType -> Bool
$c/= :: VariantType -> VariantType -> Bool
/= :: VariantType -> VariantType -> Bool
Eq)
instance SP.ManagedPtrNewtype VariantType where
toManagedPtr :: VariantType -> ManagedPtr VariantType
toManagedPtr (VariantType ManagedPtr VariantType
p) = ManagedPtr VariantType
p
foreign import ccall "g_variant_type_get_gtype" c_g_variant_type_get_gtype ::
IO GType
type instance O.ParentTypes VariantType = '[]
instance O.HasParentTypes VariantType
instance B.Types.TypedObject VariantType where
glibType :: IO GType
glibType = IO GType
c_g_variant_type_get_gtype
instance B.Types.GBoxed VariantType
instance B.GValue.IsGValue (Maybe VariantType) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_variant_type_get_gtype
gvalueSet_ :: Ptr GValue -> Maybe VariantType -> IO ()
gvalueSet_ Ptr GValue
gv Maybe VariantType
P.Nothing = Ptr GValue -> Ptr VariantType -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr VariantType
forall a. Ptr a
FP.nullPtr :: FP.Ptr VariantType)
gvalueSet_ Ptr GValue
gv (P.Just VariantType
obj) = VariantType -> (Ptr VariantType -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VariantType
obj (Ptr GValue -> Ptr VariantType -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe VariantType)
gvalueGet_ Ptr GValue
gv = do
ptr <- Ptr GValue -> IO (Ptr VariantType)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr VariantType)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newBoxed VariantType ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VariantType
type instance O.AttributeList VariantType = VariantTypeAttributeList
type VariantTypeAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_variant_type_new" g_variant_type_new ::
CString ->
IO (Ptr VariantType)
variantTypeNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m VariantType
variantTypeNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m VariantType
variantTypeNew Text
typeString = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
typeString' <- Text -> IO CString
textToCString Text
typeString
result <- g_variant_type_new typeString'
checkUnexpectedReturnNULL "variantTypeNew" result
result' <- (wrapBoxed VariantType) result
freeMem typeString'
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_type_new_array" g_variant_type_new_array ::
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeNewArray ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m VariantType
variantTypeNewArray :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeNewArray VariantType
element = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
element' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
element
result <- g_variant_type_new_array element'
checkUnexpectedReturnNULL "variantTypeNewArray" result
result' <- (wrapBoxed VariantType) result
touchManagedPtr element
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_type_new_dict_entry" g_variant_type_new_dict_entry ::
Ptr VariantType ->
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeNewDictEntry ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> VariantType
-> m VariantType
variantTypeNewDictEntry :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> VariantType -> m VariantType
variantTypeNewDictEntry VariantType
key VariantType
value = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
key' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
key
value' <- unsafeManagedPtrGetPtr value
result <- g_variant_type_new_dict_entry key' value'
checkUnexpectedReturnNULL "variantTypeNewDictEntry" result
result' <- (wrapBoxed VariantType) result
touchManagedPtr key
touchManagedPtr value
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_type_new_maybe" g_variant_type_new_maybe ::
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeNewMaybe ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m VariantType
variantTypeNewMaybe :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeNewMaybe VariantType
element = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
element' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
element
result <- g_variant_type_new_maybe element'
checkUnexpectedReturnNULL "variantTypeNewMaybe" result
result' <- (wrapBoxed VariantType) result
touchManagedPtr element
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_type_new_tuple" g_variant_type_new_tuple ::
Ptr (Ptr VariantType) ->
Int32 ->
IO (Ptr VariantType)
variantTypeNewTuple ::
(B.CallStack.HasCallStack, MonadIO m) =>
[VariantType]
-> m VariantType
variantTypeNewTuple :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[VariantType] -> m VariantType
variantTypeNewTuple [VariantType]
items = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
let length_ :: Int32
length_ = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [VariantType] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [VariantType]
items
items' <- (VariantType -> IO (Ptr VariantType))
-> [VariantType] -> IO [Ptr VariantType]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [VariantType]
items
items'' <- packPtrArray items'
result <- g_variant_type_new_tuple items'' length_
checkUnexpectedReturnNULL "variantTypeNewTuple" result
result' <- (wrapBoxed VariantType) result
mapM_ touchManagedPtr items
freeMem items''
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_type_copy" g_variant_type_copy ::
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m VariantType
variantTypeCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeCopy VariantType
type_ = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_copy type_'
checkUnexpectedReturnNULL "variantTypeCopy" result
result' <- (wrapBoxed VariantType) result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeCopyMethodInfo
instance (signature ~ (m VariantType), MonadIO m) => O.OverloadedMethod VariantTypeCopyMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m VariantType
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeCopy
instance O.OverloadedMethodInfo VariantTypeCopyMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeCopy",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeCopy"
})
#endif
foreign import ccall "g_variant_type_dup_string" g_variant_type_dup_string ::
Ptr VariantType ->
IO CString
variantTypeDupString ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m T.Text
variantTypeDupString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Text
variantTypeDupString VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_dup_string type_'
checkUnexpectedReturnNULL "variantTypeDupString" result
result' <- cstringToText result
freeMem result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeDupStringMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod VariantTypeDupStringMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Text
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Text
variantTypeDupString
instance O.OverloadedMethodInfo VariantTypeDupStringMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeDupString",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeDupString"
})
#endif
foreign import ccall "g_variant_type_element" g_variant_type_element ::
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeElement ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m VariantType
variantTypeElement :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeElement VariantType
type_ = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_element type_'
checkUnexpectedReturnNULL "variantTypeElement" result
result' <- (newBoxed VariantType) result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeElementMethodInfo
instance (signature ~ (m VariantType), MonadIO m) => O.OverloadedMethod VariantTypeElementMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m VariantType
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeElement
instance O.OverloadedMethodInfo VariantTypeElementMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeElement",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeElement"
})
#endif
foreign import ccall "g_variant_type_equal" g_variant_type_equal ::
Ptr VariantType ->
Ptr VariantType ->
IO CInt
variantTypeEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> VariantType
-> m Bool
variantTypeEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> VariantType -> m Bool
variantTypeEqual VariantType
type1 VariantType
type2 = 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
type1' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type1
type2' <- unsafeManagedPtrGetPtr type2
result <- g_variant_type_equal type1' type2'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type1
touchManagedPtr type2
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeEqualMethodInfo
instance (signature ~ (VariantType -> m Bool), MonadIO m) => O.OverloadedMethod VariantTypeEqualMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> VariantType -> m Bool
variantTypeEqual
instance O.OverloadedMethodInfo VariantTypeEqualMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeEqual",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeEqual"
})
#endif
foreign import ccall "g_variant_type_first" g_variant_type_first ::
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeFirst ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m (Maybe VariantType)
variantTypeFirst :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m (Maybe VariantType)
variantTypeFirst VariantType
type_ = IO (Maybe VariantType) -> m (Maybe VariantType)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VariantType) -> m (Maybe VariantType))
-> IO (Maybe VariantType) -> m (Maybe VariantType)
forall a b. (a -> b) -> a -> b
$ do
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_first type_'
maybeResult <- convertIfNonNull result $ \Ptr VariantType
result' -> do
result'' <- ((ManagedPtr VariantType -> VariantType)
-> Ptr VariantType -> IO VariantType
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VariantType -> VariantType
VariantType) Ptr VariantType
result'
return result''
touchManagedPtr type_
return maybeResult
#if defined(ENABLE_OVERLOADING)
data VariantTypeFirstMethodInfo
instance (signature ~ (m (Maybe VariantType)), MonadIO m) => O.OverloadedMethod VariantTypeFirstMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m (Maybe VariantType)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m (Maybe VariantType)
variantTypeFirst
instance O.OverloadedMethodInfo VariantTypeFirstMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeFirst",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeFirst"
})
#endif
foreign import ccall "g_variant_type_free" g_variant_type_free ::
Ptr VariantType ->
IO ()
variantTypeFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (VariantType)
-> m ()
variantTypeFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe VariantType -> m ()
variantTypeFree Maybe VariantType
type_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
maybeType_ <- case Maybe VariantType
type_ of
Maybe VariantType
Nothing -> Ptr VariantType -> IO (Ptr VariantType)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
forall a. Ptr a
FP.nullPtr
Just VariantType
jType_ -> do
jType_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jType_
return jType_'
g_variant_type_free maybeType_
whenJust type_ touchManagedPtr
return ()
#if defined(ENABLE_OVERLOADING)
data VariantTypeFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VariantTypeFreeMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod VariantType
i = Maybe VariantType -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe VariantType -> m ()
variantTypeFree (VariantType -> Maybe VariantType
forall a. a -> Maybe a
Just VariantType
i)
instance O.OverloadedMethodInfo VariantTypeFreeMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeFree",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeFree"
})
#endif
foreign import ccall "g_variant_type_get_string_length" g_variant_type_get_string_length ::
Ptr VariantType ->
IO FCT.CSize
variantTypeGetStringLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m FCT.CSize
variantTypeGetStringLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m CSize
variantTypeGetStringLength VariantType
type_ = 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
$ do
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_get_string_length type_'
touchManagedPtr type_
return result
#if defined(ENABLE_OVERLOADING)
data VariantTypeGetStringLengthMethodInfo
instance (signature ~ (m FCT.CSize), MonadIO m) => O.OverloadedMethod VariantTypeGetStringLengthMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m CSize
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m CSize
variantTypeGetStringLength
instance O.OverloadedMethodInfo VariantTypeGetStringLengthMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeGetStringLength",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeGetStringLength"
})
#endif
foreign import ccall "g_variant_type_hash" g_variant_type_hash ::
Ptr VariantType ->
IO Word32
variantTypeHash ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Word32
variantTypeHash :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Word32
variantTypeHash VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_hash type_'
touchManagedPtr type_
return result
#if defined(ENABLE_OVERLOADING)
data VariantTypeHashMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod VariantTypeHashMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Word32
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Word32
variantTypeHash
instance O.OverloadedMethodInfo VariantTypeHashMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeHash",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeHash"
})
#endif
foreign import ccall "g_variant_type_is_array" g_variant_type_is_array ::
Ptr VariantType ->
IO CInt
variantTypeIsArray ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Bool
variantTypeIsArray :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsArray VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_is_array type_'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsArrayMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsArrayMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsArray
instance O.OverloadedMethodInfo VariantTypeIsArrayMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsArray",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsArray"
})
#endif
foreign import ccall "g_variant_type_is_basic" g_variant_type_is_basic ::
Ptr VariantType ->
IO CInt
variantTypeIsBasic ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Bool
variantTypeIsBasic :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsBasic VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_is_basic type_'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsBasicMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsBasicMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsBasic
instance O.OverloadedMethodInfo VariantTypeIsBasicMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsBasic",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsBasic"
})
#endif
foreign import ccall "g_variant_type_is_container" g_variant_type_is_container ::
Ptr VariantType ->
IO CInt
variantTypeIsContainer ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Bool
variantTypeIsContainer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsContainer VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_is_container type_'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsContainerMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsContainerMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsContainer
instance O.OverloadedMethodInfo VariantTypeIsContainerMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsContainer",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsContainer"
})
#endif
foreign import ccall "g_variant_type_is_definite" g_variant_type_is_definite ::
Ptr VariantType ->
IO CInt
variantTypeIsDefinite ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Bool
variantTypeIsDefinite :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsDefinite VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_is_definite type_'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsDefiniteMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsDefiniteMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsDefinite
instance O.OverloadedMethodInfo VariantTypeIsDefiniteMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsDefinite",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsDefinite"
})
#endif
foreign import ccall "g_variant_type_is_dict_entry" g_variant_type_is_dict_entry ::
Ptr VariantType ->
IO CInt
variantTypeIsDictEntry ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Bool
variantTypeIsDictEntry :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsDictEntry VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_is_dict_entry type_'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsDictEntryMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsDictEntryMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsDictEntry
instance O.OverloadedMethodInfo VariantTypeIsDictEntryMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsDictEntry",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsDictEntry"
})
#endif
foreign import ccall "g_variant_type_is_maybe" g_variant_type_is_maybe ::
Ptr VariantType ->
IO CInt
variantTypeIsMaybe ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Bool
variantTypeIsMaybe :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsMaybe VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_is_maybe type_'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsMaybeMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsMaybeMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsMaybe
instance O.OverloadedMethodInfo VariantTypeIsMaybeMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsMaybe",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsMaybe"
})
#endif
foreign import ccall "g_variant_type_is_subtype_of" g_variant_type_is_subtype_of ::
Ptr VariantType ->
Ptr VariantType ->
IO CInt
variantTypeIsSubtypeOf ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> VariantType
-> m Bool
variantTypeIsSubtypeOf :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> VariantType -> m Bool
variantTypeIsSubtypeOf VariantType
type_ VariantType
supertype = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
supertype' <- unsafeManagedPtrGetPtr supertype
result <- g_variant_type_is_subtype_of type_' supertype'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
touchManagedPtr supertype
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsSubtypeOfMethodInfo
instance (signature ~ (VariantType -> m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsSubtypeOfMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> VariantType -> m Bool
variantTypeIsSubtypeOf
instance O.OverloadedMethodInfo VariantTypeIsSubtypeOfMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsSubtypeOf",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsSubtypeOf"
})
#endif
foreign import ccall "g_variant_type_is_tuple" g_variant_type_is_tuple ::
Ptr VariantType ->
IO CInt
variantTypeIsTuple ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Bool
variantTypeIsTuple :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsTuple VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_is_tuple type_'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsTupleMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsTupleMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsTuple
instance O.OverloadedMethodInfo VariantTypeIsTupleMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsTuple",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsTuple"
})
#endif
foreign import ccall "g_variant_type_is_variant" g_variant_type_is_variant ::
Ptr VariantType ->
IO CInt
variantTypeIsVariant ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m Bool
variantTypeIsVariant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsVariant VariantType
type_ = 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
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_is_variant type_'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeIsVariantMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod VariantTypeIsVariantMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m Bool
variantTypeIsVariant
instance O.OverloadedMethodInfo VariantTypeIsVariantMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeIsVariant",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeIsVariant"
})
#endif
foreign import ccall "g_variant_type_key" g_variant_type_key ::
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeKey ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m VariantType
variantTypeKey :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeKey VariantType
type_ = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_key type_'
checkUnexpectedReturnNULL "variantTypeKey" result
result' <- (newBoxed VariantType) result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeKeyMethodInfo
instance (signature ~ (m VariantType), MonadIO m) => O.OverloadedMethod VariantTypeKeyMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m VariantType
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeKey
instance O.OverloadedMethodInfo VariantTypeKeyMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeKey",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeKey"
})
#endif
foreign import ccall "g_variant_type_n_items" g_variant_type_n_items ::
Ptr VariantType ->
IO FCT.CSize
variantTypeNItems ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m FCT.CSize
variantTypeNItems :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m CSize
variantTypeNItems VariantType
type_ = 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
$ do
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_n_items type_'
touchManagedPtr type_
return result
#if defined(ENABLE_OVERLOADING)
data VariantTypeNItemsMethodInfo
instance (signature ~ (m FCT.CSize), MonadIO m) => O.OverloadedMethod VariantTypeNItemsMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m CSize
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m CSize
variantTypeNItems
instance O.OverloadedMethodInfo VariantTypeNItemsMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeNItems",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeNItems"
})
#endif
foreign import ccall "g_variant_type_next" g_variant_type_next ::
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeNext ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m (Maybe VariantType)
variantTypeNext :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m (Maybe VariantType)
variantTypeNext VariantType
type_ = IO (Maybe VariantType) -> m (Maybe VariantType)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VariantType) -> m (Maybe VariantType))
-> IO (Maybe VariantType) -> m (Maybe VariantType)
forall a b. (a -> b) -> a -> b
$ do
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_next type_'
maybeResult <- convertIfNonNull result $ \Ptr VariantType
result' -> do
result'' <- ((ManagedPtr VariantType -> VariantType)
-> Ptr VariantType -> IO VariantType
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VariantType -> VariantType
VariantType) Ptr VariantType
result'
return result''
touchManagedPtr type_
return maybeResult
#if defined(ENABLE_OVERLOADING)
data VariantTypeNextMethodInfo
instance (signature ~ (m (Maybe VariantType)), MonadIO m) => O.OverloadedMethod VariantTypeNextMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m (Maybe VariantType)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m (Maybe VariantType)
variantTypeNext
instance O.OverloadedMethodInfo VariantTypeNextMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeNext",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeNext"
})
#endif
foreign import ccall "g_variant_type_value" g_variant_type_value ::
Ptr VariantType ->
IO (Ptr VariantType)
variantTypeValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
VariantType
-> m VariantType
variantTypeValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeValue VariantType
type_ = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
type_' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
type_
result <- g_variant_type_value type_'
checkUnexpectedReturnNULL "variantTypeValue" result
result' <- (newBoxed VariantType) result
touchManagedPtr type_
return result'
#if defined(ENABLE_OVERLOADING)
data VariantTypeValueMethodInfo
instance (signature ~ (m VariantType), MonadIO m) => O.OverloadedMethod VariantTypeValueMethodInfo VariantType signature where
overloadedMethod :: VariantType -> signature
overloadedMethod = VariantType -> signature
VariantType -> m VariantType
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VariantType -> m VariantType
variantTypeValue
instance O.OverloadedMethodInfo VariantTypeValueMethodInfo VariantType where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.VariantType.variantTypeValue",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-VariantType.html#v:variantTypeValue"
})
#endif
foreign import ccall "g_variant_type_checked_" g_variant_type_checked_ ::
CString ->
IO (Ptr VariantType)
variantTypeChecked_ ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m VariantType
variantTypeChecked_ :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m VariantType
variantTypeChecked_ Text
typeString = IO VariantType -> m VariantType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VariantType -> m VariantType)
-> IO VariantType -> m VariantType
forall a b. (a -> b) -> a -> b
$ do
typeString' <- Text -> IO CString
textToCString Text
typeString
result <- g_variant_type_checked_ typeString'
checkUnexpectedReturnNULL "variantTypeChecked_" result
result' <- (newBoxed VariantType) result
freeMem typeString'
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_type_string_get_depth_" g_variant_type_string_get_depth_ ::
CString ->
IO FCT.CSize
variantTypeStringGetDepth_ ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m FCT.CSize
variantTypeStringGetDepth_ :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m CSize
variantTypeStringGetDepth_ Text
typeString = 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
$ do
typeString' <- Text -> IO CString
textToCString Text
typeString
result <- g_variant_type_string_get_depth_ typeString'
freeMem typeString'
return result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_type_string_is_valid" g_variant_type_string_is_valid ::
CString ->
IO CInt
variantTypeStringIsValid ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
variantTypeStringIsValid :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bool
variantTypeStringIsValid Text
typeString = 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
typeString' <- Text -> IO CString
textToCString Text
typeString
result <- g_variant_type_string_is_valid typeString'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
freeMem typeString'
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_variant_type_string_scan" g_variant_type_string_scan ::
CString ->
CString ->
Ptr CString ->
IO CInt
variantTypeStringScan ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Maybe (T.Text)
-> m ((Bool, T.Text))
variantTypeStringScan :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Maybe Text -> m (Bool, Text)
variantTypeStringScan Text
string Maybe Text
limit = IO (Bool, Text) -> m (Bool, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text) -> m (Bool, Text))
-> IO (Bool, Text) -> m (Bool, Text)
forall a b. (a -> b) -> a -> b
$ do
string' <- Text -> IO CString
textToCString Text
string
maybeLimit <- case limit 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
jLimit -> do
jLimit' <- Text -> IO CString
textToCString Text
jLimit
return jLimit'
endptr <- callocMem :: IO (Ptr CString)
result <- g_variant_type_string_scan string' maybeLimit endptr
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
endptr' <- peek endptr
endptr'' <- cstringToText endptr'
freeMem endptr'
freeMem string'
freeMem maybeLimit
freeMem endptr
return (result', endptr'')
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveVariantTypeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveVariantTypeMethod "copy" o = VariantTypeCopyMethodInfo
ResolveVariantTypeMethod "dupString" o = VariantTypeDupStringMethodInfo
ResolveVariantTypeMethod "element" o = VariantTypeElementMethodInfo
ResolveVariantTypeMethod "equal" o = VariantTypeEqualMethodInfo
ResolveVariantTypeMethod "first" o = VariantTypeFirstMethodInfo
ResolveVariantTypeMethod "free" o = VariantTypeFreeMethodInfo
ResolveVariantTypeMethod "hash" o = VariantTypeHashMethodInfo
ResolveVariantTypeMethod "isArray" o = VariantTypeIsArrayMethodInfo
ResolveVariantTypeMethod "isBasic" o = VariantTypeIsBasicMethodInfo
ResolveVariantTypeMethod "isContainer" o = VariantTypeIsContainerMethodInfo
ResolveVariantTypeMethod "isDefinite" o = VariantTypeIsDefiniteMethodInfo
ResolveVariantTypeMethod "isDictEntry" o = VariantTypeIsDictEntryMethodInfo
ResolveVariantTypeMethod "isMaybe" o = VariantTypeIsMaybeMethodInfo
ResolveVariantTypeMethod "isSubtypeOf" o = VariantTypeIsSubtypeOfMethodInfo
ResolveVariantTypeMethod "isTuple" o = VariantTypeIsTupleMethodInfo
ResolveVariantTypeMethod "isVariant" o = VariantTypeIsVariantMethodInfo
ResolveVariantTypeMethod "key" o = VariantTypeKeyMethodInfo
ResolveVariantTypeMethod "nItems" o = VariantTypeNItemsMethodInfo
ResolveVariantTypeMethod "next" o = VariantTypeNextMethodInfo
ResolveVariantTypeMethod "value" o = VariantTypeValueMethodInfo
ResolveVariantTypeMethod "getStringLength" o = VariantTypeGetStringLengthMethodInfo
ResolveVariantTypeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveVariantTypeMethod t VariantType, O.OverloadedMethod info VariantType p) => OL.IsLabel t (VariantType -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: VariantType -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveVariantTypeMethod t VariantType, O.OverloadedMethod info VariantType p, R.HasField t VariantType p) => R.HasField t VariantType p where
getField :: VariantType -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#endif
instance (info ~ ResolveVariantTypeMethod t VariantType, O.OverloadedMethodInfo info VariantType) => OL.IsLabel t (O.MethodProxy info VariantType) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: MethodProxy info VariantType
fromLabel = MethodProxy info VariantType
forall info obj. MethodProxy info obj
O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif