{-# LINE 1 "Data/GI/Base/GVariant.hsc" #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE EmptyDataDecls #-}
module Data.GI.Base.GVariant
( IsGVariant(..)
, IsGVariantBasicType
, noGVariant
, gvariantGetTypeString
, GVariantSinglet(GVariantSinglet)
, GVariantDictEntry(GVariantDictEntry)
, GVariantHandle(GVariantHandle)
, GVariantObjectPath
, newGVariantObjectPath
, gvariantObjectPathToText
, GVariantSignature
, newGVariantSignature
, gvariantSignatureToText
, wrapGVariantPtr
, newGVariantFromPtr
, unrefGVariant
, disownGVariant
, gvariantToBool
, gvariantFromBool
, gvariantToWord8
, gvariantFromWord8
, gvariantToInt16
, gvariantFromInt16
, gvariantToWord16
, gvariantFromWord16
, gvariantToInt32
, gvariantFromInt32
, gvariantToWord32
, gvariantFromWord32
, gvariantToInt64
, gvariantFromInt64
, gvariantToWord64
, gvariantFromWord64
, gvariantToHandle
, gvariantFromHandle
, gvariantToDouble
, gvariantFromDouble
, gvariantToText
, gvariantFromText
, gvariantToObjectPath
, gvariantFromObjectPath
, gvariantToSignature
, gvariantFromSignature
, gvariantToGVariant
, gvariantFromGVariant
, gvariantToBytestring
, gvariantFromBytestring
, gvariantFromMaybe
, gvariantToMaybe
, gvariantFromDictEntry
, gvariantToDictEntry
, gvariantFromMap
, gvariantToMap
, gvariantFromList
, gvariantToList
, gvariantFromTuple
, gvariantToTuple
) where
import Control.Monad (when, void, (>=>))
import Control.Exception.Base (bracket)
import Data.Text (Text)
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import Data.Word
import Data.Int
{-# LINE 147 "Data/GI/Base/GVariant.hsc" #-}
import Data.Maybe (isJust, fromJust)
import qualified Data.Map as M
import System.IO.Unsafe (unsafePerformIO)
import Foreign.C
import Foreign.Ptr
import Data.GI.Base.BasicTypes (GVariant(..))
import Data.GI.Base.BasicConversions
import Data.GI.Base.ManagedPtr (withManagedPtr, withManagedPtrList,
newManagedPtr', disownManagedPtr)
import Data.GI.Base.Utils (freeMem)
noGVariant :: Maybe GVariant
noGVariant :: Maybe GVariant
noGVariant = forall a. Maybe a
Nothing
class IsGVariant a where
toGVariant :: a -> IO GVariant
fromGVariant :: GVariant -> IO (Maybe a)
toGVariantFormatString :: a -> Text
unsafeFromGVariant :: IsGVariant a => GVariant -> IO a
unsafeFromGVariant :: forall a. IsGVariant a => GVariant -> IO a
unsafeFromGVariant GVariant
gv =
forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
gv forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
Maybe a
Nothing -> forall a. HasCallStack => [Char] -> a
error [Char]
"Error decoding GVariant. This is a bug in haskell-gi, please report it."
Just a
value -> forall (m :: * -> *) a. Monad m => a -> m a
return a
value
class Ord a => IsGVariantBasicType a
newtype GVariantSinglet a = GVariantSinglet a
deriving (GVariantSinglet a -> GVariantSinglet a -> Bool
forall a. Eq a => GVariantSinglet a -> GVariantSinglet a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GVariantSinglet a -> GVariantSinglet a -> Bool
$c/= :: forall a. Eq a => GVariantSinglet a -> GVariantSinglet a -> Bool
== :: GVariantSinglet a -> GVariantSinglet a -> Bool
$c== :: forall a. Eq a => GVariantSinglet a -> GVariantSinglet a -> Bool
Eq, Int -> GVariantSinglet a -> ShowS
forall a. Show a => Int -> GVariantSinglet a -> ShowS
forall a. Show a => [GVariantSinglet a] -> ShowS
forall a. Show a => GVariantSinglet a -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [GVariantSinglet a] -> ShowS
$cshowList :: forall a. Show a => [GVariantSinglet a] -> ShowS
show :: GVariantSinglet a -> [Char]
$cshow :: forall a. Show a => GVariantSinglet a -> [Char]
showsPrec :: Int -> GVariantSinglet a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> GVariantSinglet a -> ShowS
Show)
data GVariantType
foreign import ccall "g_variant_type_new" g_variant_type_new ::
CString -> IO (Ptr GVariantType)
foreign import ccall "g_variant_type_free" g_variant_type_free ::
Ptr GVariantType -> IO ()
foreign import ccall "g_variant_is_of_type" g_variant_is_of_type ::
Ptr GVariant -> Ptr GVariantType -> IO Int32
{-# LINE 210 "Data/GI/Base/GVariant.hsc" #-}
withGVariantType :: Text -> (Ptr GVariantType -> IO a) -> IO a
withGVariantType :: forall a. Text -> (Ptr GVariantType -> IO a) -> IO a
withGVariantType Text
text Ptr GVariantType -> IO a
action = forall a. Text -> (CString -> IO a) -> IO a
withTextCString Text
text forall a b. (a -> b) -> a -> b
$ \CString
textPtr ->
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket (CString -> IO (Ptr GVariantType)
g_variant_type_new CString
textPtr)
Ptr GVariantType -> IO ()
g_variant_type_free
Ptr GVariantType -> IO a
action
gvariantIsOfType :: Text -> GVariant -> IO Bool
gvariantIsOfType :: Text -> GVariant -> IO Bool
gvariantIsOfType Text
typeString GVariant
variant =
forall a. Text -> (Ptr GVariantType -> IO a) -> IO a
withGVariantType Text
typeString forall a b. (a -> b) -> a -> b
$
\Ptr GVariantType
typePtr ->
(forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GVariant
variant
(\Ptr GVariant
vptr -> Ptr GVariant -> Ptr GVariantType -> IO Int32
g_variant_is_of_type
Ptr GVariant
vptr Ptr GVariantType
typePtr)
withExplicitType :: Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType :: forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
format Ptr GVariant -> IO a
action GVariant
variant = do
Bool
check <- Text -> GVariant -> IO Bool
gvariantIsOfType Text
format GVariant
variant
if Bool
check
then forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GVariant
variant Ptr GVariant -> IO a
action
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
withTypeCheck :: forall a. (IsGVariant a) =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck :: forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck = forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType forall a b. (a -> b) -> a -> b
$ forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
foreign import ccall "g_variant_get_type_string" g_variant_get_type_string
:: Ptr GVariant -> IO CString
gvariantGetTypeString :: GVariant -> IO Text
gvariantGetTypeString :: GVariant -> IO Text
gvariantGetTypeString GVariant
variant =
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GVariant
variant (Ptr GVariant -> IO CString
g_variant_get_type_string forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> HasCallStack => CString -> IO Text
cstringToText)
foreign import ccall "g_variant_is_floating" g_variant_is_floating ::
Ptr GVariant -> IO CInt
foreign import ccall "g_variant_ref_sink" g_variant_ref_sink ::
Ptr GVariant -> IO (Ptr GVariant)
foreign import ccall "g_variant_ref" g_variant_ref ::
Ptr GVariant -> IO (Ptr GVariant)
foreign import ccall "g_variant_unref" g_variant_unref ::
Ptr GVariant -> IO ()
foreign import ccall "&g_variant_unref" ptr_to_g_variant_unref ::
FunPtr (Ptr GVariant -> IO ())
wrapGVariantPtr :: Ptr GVariant -> IO GVariant
wrapGVariantPtr :: Ptr GVariant -> IO GVariant
wrapGVariantPtr Ptr GVariant
ptr = do
CInt
floating <- Ptr GVariant -> IO CInt
g_variant_is_floating Ptr GVariant
ptr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CInt
floating forall a. Eq a => a -> a -> Bool
/= CInt
0) forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO (Ptr GVariant)
g_variant_ref_sink Ptr GVariant
ptr
ManagedPtr GVariant
fPtr <- forall a.
HasCallStack =>
FinalizerPtr a -> Ptr a -> IO (ManagedPtr a)
newManagedPtr' FunPtr (Ptr GVariant -> IO ())
ptr_to_g_variant_unref Ptr GVariant
ptr
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! ManagedPtr GVariant -> GVariant
GVariant ManagedPtr GVariant
fPtr
newGVariantFromPtr :: Ptr GVariant -> IO GVariant
newGVariantFromPtr :: Ptr GVariant -> IO GVariant
newGVariantFromPtr Ptr GVariant
ptr = do
ManagedPtr GVariant
fPtr <- Ptr GVariant -> IO (Ptr GVariant)
g_variant_ref Ptr GVariant
ptr forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
HasCallStack =>
FinalizerPtr a -> Ptr a -> IO (ManagedPtr a)
newManagedPtr' FunPtr (Ptr GVariant -> IO ())
ptr_to_g_variant_unref
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! ManagedPtr GVariant -> GVariant
GVariant ManagedPtr GVariant
fPtr
unrefGVariant :: GVariant -> IO ()
unrefGVariant :: GVariant -> IO ()
unrefGVariant GVariant
gv = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GVariant
gv Ptr GVariant -> IO ()
g_variant_unref
disownGVariant :: GVariant -> IO (Ptr GVariant)
disownGVariant :: GVariant -> IO (Ptr GVariant)
disownGVariant = forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
disownManagedPtr
instance IsGVariant Bool where
toGVariant :: Bool -> IO GVariant
toGVariant = Bool -> IO GVariant
gvariantFromBool
fromGVariant :: GVariant -> IO (Maybe Bool)
fromGVariant = GVariant -> IO (Maybe Bool)
gvariantToBool
toGVariantFormatString :: Bool -> Text
toGVariantFormatString Bool
_ = Text
"b"
instance IsGVariantBasicType Bool
foreign import ccall "g_variant_new_boolean" new_bool
:: Int32 -> IO (Ptr GVariant)
{-# LINE 291 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromBool :: Bool -> IO GVariant
gvariantFromBool :: Bool -> IO GVariant
gvariantFromBool = (Int32 -> IO (Ptr GVariant)
new_bool forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_boolean" get_bool
:: Ptr GVariant -> IO Int32
{-# LINE 297 "Data/GI/Base/GVariant.hsc" #-}
gvariantToBool :: GVariant -> IO (Maybe Bool)
gvariantToBool :: GVariant -> IO (Maybe Bool)
gvariantToBool = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Int32
get_bool forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
instance IsGVariant Word8 where
toGVariant :: Word8 -> IO GVariant
toGVariant = Word8 -> IO GVariant
gvariantFromWord8
fromGVariant :: GVariant -> IO (Maybe Word8)
fromGVariant = GVariant -> IO (Maybe Word8)
gvariantToWord8
toGVariantFormatString :: Word8 -> Text
toGVariantFormatString Word8
_ = Text
"y"
instance IsGVariantBasicType Word8
foreign import ccall "g_variant_new_byte" new_byte
:: Word8 -> IO (Ptr GVariant)
{-# LINE 309 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromWord8 :: Word8 -> IO GVariant
gvariantFromWord8 :: Word8 -> IO GVariant
gvariantFromWord8 = (Word8 -> IO (Ptr GVariant)
new_byte forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_byte" get_byte
:: Ptr GVariant -> IO Word8
{-# LINE 315 "Data/GI/Base/GVariant.hsc" #-}
gvariantToWord8 :: GVariant -> IO (Maybe Word8)
gvariantToWord8 :: GVariant -> IO (Maybe Word8)
gvariantToWord8 = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Word8
get_byte forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
instance IsGVariant Int16 where
toGVariant :: Int16 -> IO GVariant
toGVariant = Int16 -> IO GVariant
gvariantFromInt16
fromGVariant :: GVariant -> IO (Maybe Int16)
fromGVariant = GVariant -> IO (Maybe Int16)
gvariantToInt16
toGVariantFormatString :: Int16 -> Text
toGVariantFormatString Int16
_ = Text
"n"
instance IsGVariantBasicType Int16
foreign import ccall "g_variant_new_int16" new_int16
:: Int16 -> IO (Ptr GVariant)
{-# LINE 327 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromInt16 :: Int16 -> IO GVariant
gvariantFromInt16 :: Int16 -> IO GVariant
gvariantFromInt16 = (Int16 -> IO (Ptr GVariant)
new_int16 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_int16" get_int16
:: Ptr GVariant -> IO Int16
{-# LINE 333 "Data/GI/Base/GVariant.hsc" #-}
gvariantToInt16 :: GVariant -> IO (Maybe Int16)
gvariantToInt16 :: GVariant -> IO (Maybe Int16)
gvariantToInt16 = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Int16
get_int16 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
instance IsGVariant Word16 where
toGVariant :: Word16 -> IO GVariant
toGVariant = Word16 -> IO GVariant
gvariantFromWord16
fromGVariant :: GVariant -> IO (Maybe Word16)
fromGVariant = GVariant -> IO (Maybe Word16)
gvariantToWord16
toGVariantFormatString :: Word16 -> Text
toGVariantFormatString Word16
_ = Text
"q"
instance IsGVariantBasicType Word16
foreign import ccall "g_variant_new_uint16" new_uint16
:: Word16 -> IO (Ptr GVariant)
{-# LINE 345 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromWord16 :: Word16 -> IO GVariant
gvariantFromWord16 :: Word16 -> IO GVariant
gvariantFromWord16 = Word16 -> IO (Ptr GVariant)
new_uint16 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_uint16" get_uint16
:: Ptr GVariant -> IO Word16
{-# LINE 351 "Data/GI/Base/GVariant.hsc" #-}
gvariantToWord16 :: GVariant -> IO (Maybe Word16)
gvariantToWord16 :: GVariant -> IO (Maybe Word16)
gvariantToWord16 = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Word16
get_uint16 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
instance IsGVariant Int32 where
toGVariant :: Int32 -> IO GVariant
toGVariant = Int32 -> IO GVariant
gvariantFromInt32
fromGVariant :: GVariant -> IO (Maybe Int32)
fromGVariant = GVariant -> IO (Maybe Int32)
gvariantToInt32
toGVariantFormatString :: Int32 -> Text
toGVariantFormatString Int32
_ = Text
"i"
instance IsGVariantBasicType Int32
foreign import ccall "g_variant_new_int32" new_int32
:: Int16 -> IO (Ptr GVariant)
{-# LINE 363 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromInt32 :: Int32 -> IO GVariant
gvariantFromInt32 :: Int32 -> IO GVariant
gvariantFromInt32 = (Int16 -> IO (Ptr GVariant)
new_int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_int32" get_int32
:: Ptr GVariant -> IO Int32
{-# LINE 369 "Data/GI/Base/GVariant.hsc" #-}
gvariantToInt32 :: GVariant -> IO (Maybe Int32)
gvariantToInt32 :: GVariant -> IO (Maybe Int32)
gvariantToInt32 = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Int32
get_int32 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
instance IsGVariant Word32 where
toGVariant :: Word32 -> IO GVariant
toGVariant = Word32 -> IO GVariant
gvariantFromWord32
fromGVariant :: GVariant -> IO (Maybe Word32)
fromGVariant = GVariant -> IO (Maybe Word32)
gvariantToWord32
toGVariantFormatString :: Word32 -> Text
toGVariantFormatString Word32
_ = Text
"u"
instance IsGVariantBasicType Word32
foreign import ccall "g_variant_new_uint32" new_uint32
:: Word32 -> IO (Ptr GVariant)
{-# LINE 381 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromWord32 :: Word32 -> IO GVariant
gvariantFromWord32 :: Word32 -> IO GVariant
gvariantFromWord32 = (Word32 -> IO (Ptr GVariant)
new_uint32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_uint32" get_uint32
:: Ptr GVariant -> IO Word32
{-# LINE 387 "Data/GI/Base/GVariant.hsc" #-}
gvariantToWord32 :: GVariant -> IO (Maybe Word32)
gvariantToWord32 :: GVariant -> IO (Maybe Word32)
gvariantToWord32 = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Word32
get_uint32 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
instance IsGVariant Int64 where
toGVariant :: Int64 -> IO GVariant
toGVariant = Int64 -> IO GVariant
gvariantFromInt64
fromGVariant :: GVariant -> IO (Maybe Int64)
fromGVariant = GVariant -> IO (Maybe Int64)
gvariantToInt64
toGVariantFormatString :: Int64 -> Text
toGVariantFormatString Int64
_ = Text
"x"
instance IsGVariantBasicType Int64
foreign import ccall "g_variant_new_int64" new_int64
:: Int64 -> IO (Ptr GVariant)
{-# LINE 399 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromInt64 :: Int64 -> IO GVariant
gvariantFromInt64 :: Int64 -> IO GVariant
gvariantFromInt64 = (Int64 -> IO (Ptr GVariant)
new_int64 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_int64" get_int64
:: Ptr GVariant -> IO Int64
{-# LINE 405 "Data/GI/Base/GVariant.hsc" #-}
gvariantToInt64 :: GVariant -> IO (Maybe Int64)
gvariantToInt64 :: GVariant -> IO (Maybe Int64)
gvariantToInt64 = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Int64
get_int64 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
instance IsGVariant Word64 where
toGVariant :: Word64 -> IO GVariant
toGVariant = Word64 -> IO GVariant
gvariantFromWord64
fromGVariant :: GVariant -> IO (Maybe Word64)
fromGVariant = GVariant -> IO (Maybe Word64)
gvariantToWord64
toGVariantFormatString :: Word64 -> Text
toGVariantFormatString Word64
_ = Text
"t"
instance IsGVariantBasicType Word64
foreign import ccall "g_variant_new_uint64" new_uint64
:: Word64 -> IO (Ptr GVariant)
{-# LINE 417 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromWord64 :: Word64 -> IO GVariant
gvariantFromWord64 :: Word64 -> IO GVariant
gvariantFromWord64 = (Word64 -> IO (Ptr GVariant)
new_uint64 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_uint64" get_uint64
:: Ptr GVariant -> IO Word64
{-# LINE 423 "Data/GI/Base/GVariant.hsc" #-}
gvariantToWord64 :: GVariant -> IO (Maybe Word64)
gvariantToWord64 :: GVariant -> IO (Maybe Word64)
gvariantToWord64 = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Word64
get_uint64 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
newtype GVariantHandle = GVariantHandle Int32
deriving (GVariantHandle -> GVariantHandle -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GVariantHandle -> GVariantHandle -> Bool
$c/= :: GVariantHandle -> GVariantHandle -> Bool
== :: GVariantHandle -> GVariantHandle -> Bool
$c== :: GVariantHandle -> GVariantHandle -> Bool
Eq, Eq GVariantHandle
GVariantHandle -> GVariantHandle -> Bool
GVariantHandle -> GVariantHandle -> Ordering
GVariantHandle -> GVariantHandle -> GVariantHandle
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GVariantHandle -> GVariantHandle -> GVariantHandle
$cmin :: GVariantHandle -> GVariantHandle -> GVariantHandle
max :: GVariantHandle -> GVariantHandle -> GVariantHandle
$cmax :: GVariantHandle -> GVariantHandle -> GVariantHandle
>= :: GVariantHandle -> GVariantHandle -> Bool
$c>= :: GVariantHandle -> GVariantHandle -> Bool
> :: GVariantHandle -> GVariantHandle -> Bool
$c> :: GVariantHandle -> GVariantHandle -> Bool
<= :: GVariantHandle -> GVariantHandle -> Bool
$c<= :: GVariantHandle -> GVariantHandle -> Bool
< :: GVariantHandle -> GVariantHandle -> Bool
$c< :: GVariantHandle -> GVariantHandle -> Bool
compare :: GVariantHandle -> GVariantHandle -> Ordering
$ccompare :: GVariantHandle -> GVariantHandle -> Ordering
Ord, Int -> GVariantHandle -> ShowS
[GVariantHandle] -> ShowS
GVariantHandle -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [GVariantHandle] -> ShowS
$cshowList :: [GVariantHandle] -> ShowS
show :: GVariantHandle -> [Char]
$cshow :: GVariantHandle -> [Char]
showsPrec :: Int -> GVariantHandle -> ShowS
$cshowsPrec :: Int -> GVariantHandle -> ShowS
Show)
instance IsGVariant GVariantHandle where
toGVariant :: GVariantHandle -> IO GVariant
toGVariant (GVariantHandle Int32
h) = Int32 -> IO GVariant
gvariantFromHandle Int32
h
fromGVariant :: GVariant -> IO (Maybe GVariantHandle)
fromGVariant = GVariant -> IO (Maybe Int32)
gvariantToHandle forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int32 -> GVariantHandle
GVariantHandle forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>))
toGVariantFormatString :: GVariantHandle -> Text
toGVariantFormatString GVariantHandle
_ = Text
"h"
instance IsGVariantBasicType GVariantHandle
foreign import ccall "g_variant_new_handle" new_handle
:: Int32 -> IO (Ptr GVariant)
{-# LINE 438 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromHandle :: Int32 -> IO GVariant
gvariantFromHandle :: Int32 -> IO GVariant
gvariantFromHandle Int32
h = (Int32 -> IO (Ptr GVariant)
new_handle forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) Int32
h forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_handle" get_handle
:: Ptr GVariant -> IO Int32
{-# LINE 445 "Data/GI/Base/GVariant.hsc" #-}
gvariantToHandle :: GVariant -> IO (Maybe Int32)
gvariantToHandle :: GVariant -> IO (Maybe Int32)
gvariantToHandle =
forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType (forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: GVariantHandle)) forall a b. (a -> b) -> a -> b
$
Ptr GVariant -> IO Int32
get_handle forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral)
instance IsGVariant Double where
toGVariant :: Double -> IO GVariant
toGVariant = Double -> IO GVariant
gvariantFromDouble
fromGVariant :: GVariant -> IO (Maybe Double)
fromGVariant = GVariant -> IO (Maybe Double)
gvariantToDouble
toGVariantFormatString :: Double -> Text
toGVariantFormatString Double
_ = Text
"d"
instance IsGVariantBasicType Double
foreign import ccall "g_variant_new_double" new_double
:: Double -> IO (Ptr GVariant)
{-# LINE 460 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromDouble :: Double -> IO GVariant
gvariantFromDouble :: Double -> IO GVariant
gvariantFromDouble = (Double -> IO (Ptr GVariant)
new_double forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Real a, Fractional b) => a -> b
realToFrac) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_double" get_double
:: Ptr GVariant -> IO Double
{-# LINE 466 "Data/GI/Base/GVariant.hsc" #-}
gvariantToDouble :: GVariant -> IO (Maybe Double)
gvariantToDouble :: GVariant -> IO (Maybe Double)
gvariantToDouble = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO Double
get_double forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Real a, Fractional b) => a -> b
realToFrac)
instance IsGVariant Text where
toGVariant :: Text -> IO GVariant
toGVariant = Text -> IO GVariant
gvariantFromText
fromGVariant :: GVariant -> IO (Maybe Text)
fromGVariant = GVariant -> IO (Maybe Text)
gvariantToText
toGVariantFormatString :: Text -> Text
toGVariantFormatString Text
_ = Text
"s"
instance IsGVariantBasicType Text
foreign import ccall "g_variant_get_string" _get_string
:: Ptr GVariant -> Ptr Word64 -> IO CString
{-# LINE 478 "Data/GI/Base/GVariant.hsc" #-}
get_string :: Ptr GVariant -> IO CString
get_string :: Ptr GVariant -> IO CString
get_string Ptr GVariant
v = Ptr GVariant -> Ptr Word64 -> IO CString
_get_string Ptr GVariant
v forall a. Ptr a
nullPtr
gvariantToText :: GVariant -> IO (Maybe Text)
gvariantToText :: GVariant -> IO (Maybe Text)
gvariantToText = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO CString
get_string forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> HasCallStack => CString -> IO Text
cstringToText
foreign import ccall "g_variant_new_take_string" take_string
:: CString -> IO (Ptr GVariant)
gvariantFromText :: Text -> IO GVariant
gvariantFromText :: Text -> IO GVariant
gvariantFromText = Text -> IO CString
textToCString forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CString -> IO (Ptr GVariant)
take_string forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_is_object_path" g_variant_is_object_path ::
CString -> IO Int32
{-# LINE 495 "Data/GI/Base/GVariant.hsc" #-}
newtype GVariantObjectPath = GVariantObjectPath Text
deriving (Eq GVariantObjectPath
GVariantObjectPath -> GVariantObjectPath -> Bool
GVariantObjectPath -> GVariantObjectPath -> Ordering
GVariantObjectPath -> GVariantObjectPath -> GVariantObjectPath
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GVariantObjectPath -> GVariantObjectPath -> GVariantObjectPath
$cmin :: GVariantObjectPath -> GVariantObjectPath -> GVariantObjectPath
max :: GVariantObjectPath -> GVariantObjectPath -> GVariantObjectPath
$cmax :: GVariantObjectPath -> GVariantObjectPath -> GVariantObjectPath
>= :: GVariantObjectPath -> GVariantObjectPath -> Bool
$c>= :: GVariantObjectPath -> GVariantObjectPath -> Bool
> :: GVariantObjectPath -> GVariantObjectPath -> Bool
$c> :: GVariantObjectPath -> GVariantObjectPath -> Bool
<= :: GVariantObjectPath -> GVariantObjectPath -> Bool
$c<= :: GVariantObjectPath -> GVariantObjectPath -> Bool
< :: GVariantObjectPath -> GVariantObjectPath -> Bool
$c< :: GVariantObjectPath -> GVariantObjectPath -> Bool
compare :: GVariantObjectPath -> GVariantObjectPath -> Ordering
$ccompare :: GVariantObjectPath -> GVariantObjectPath -> Ordering
Ord, GVariantObjectPath -> GVariantObjectPath -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GVariantObjectPath -> GVariantObjectPath -> Bool
$c/= :: GVariantObjectPath -> GVariantObjectPath -> Bool
== :: GVariantObjectPath -> GVariantObjectPath -> Bool
$c== :: GVariantObjectPath -> GVariantObjectPath -> Bool
Eq, Int -> GVariantObjectPath -> ShowS
[GVariantObjectPath] -> ShowS
GVariantObjectPath -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [GVariantObjectPath] -> ShowS
$cshowList :: [GVariantObjectPath] -> ShowS
show :: GVariantObjectPath -> [Char]
$cshow :: GVariantObjectPath -> [Char]
showsPrec :: Int -> GVariantObjectPath -> ShowS
$cshowsPrec :: Int -> GVariantObjectPath -> ShowS
Show)
newGVariantObjectPath :: Text -> Maybe GVariantObjectPath
newGVariantObjectPath :: Text -> Maybe GVariantObjectPath
newGVariantObjectPath Text
p = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
forall a. Text -> (CString -> IO a) -> IO a
withTextCString Text
p forall a b. (a -> b) -> a -> b
$ \CString
cstr -> do
Bool
isObjectPath <- forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CString -> IO Int32
g_variant_is_object_path CString
cstr
if Bool
isObjectPath
then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (Text -> GVariantObjectPath
GVariantObjectPath Text
p)
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
gvariantObjectPathToText :: GVariantObjectPath -> Text
gvariantObjectPathToText :: GVariantObjectPath -> Text
gvariantObjectPathToText (GVariantObjectPath Text
p) = Text
p
instance IsGVariant GVariantObjectPath where
toGVariant :: GVariantObjectPath -> IO GVariant
toGVariant = GVariantObjectPath -> IO GVariant
gvariantFromObjectPath
fromGVariant :: GVariant -> IO (Maybe GVariantObjectPath)
fromGVariant = GVariant -> IO (Maybe Text)
gvariantToObjectPath forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> GVariantObjectPath
GVariantObjectPath forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)
toGVariantFormatString :: GVariantObjectPath -> Text
toGVariantFormatString GVariantObjectPath
_ = Text
"o"
instance IsGVariantBasicType GVariantObjectPath
foreign import ccall "g_variant_new_object_path" new_object_path
:: CString -> IO (Ptr GVariant)
gvariantFromObjectPath :: GVariantObjectPath -> IO GVariant
gvariantFromObjectPath :: GVariantObjectPath -> IO GVariant
gvariantFromObjectPath (GVariantObjectPath Text
p) =
forall a. Text -> (CString -> IO a) -> IO a
withTextCString Text
p forall a b. (a -> b) -> a -> b
$ CString -> IO (Ptr GVariant)
new_object_path forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
gvariantToObjectPath :: GVariant -> IO (Maybe Text)
gvariantToObjectPath :: GVariant -> IO (Maybe Text)
gvariantToObjectPath =
forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType (forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: GVariantObjectPath))
(Ptr GVariant -> IO CString
get_string forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> HasCallStack => CString -> IO Text
cstringToText)
foreign import ccall "g_variant_is_signature" g_variant_is_signature ::
CString -> IO Int32
{-# LINE 542 "Data/GI/Base/GVariant.hsc" #-}
newtype GVariantSignature = GVariantSignature Text
deriving (Eq GVariantSignature
GVariantSignature -> GVariantSignature -> Bool
GVariantSignature -> GVariantSignature -> Ordering
GVariantSignature -> GVariantSignature -> GVariantSignature
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GVariantSignature -> GVariantSignature -> GVariantSignature
$cmin :: GVariantSignature -> GVariantSignature -> GVariantSignature
max :: GVariantSignature -> GVariantSignature -> GVariantSignature
$cmax :: GVariantSignature -> GVariantSignature -> GVariantSignature
>= :: GVariantSignature -> GVariantSignature -> Bool
$c>= :: GVariantSignature -> GVariantSignature -> Bool
> :: GVariantSignature -> GVariantSignature -> Bool
$c> :: GVariantSignature -> GVariantSignature -> Bool
<= :: GVariantSignature -> GVariantSignature -> Bool
$c<= :: GVariantSignature -> GVariantSignature -> Bool
< :: GVariantSignature -> GVariantSignature -> Bool
$c< :: GVariantSignature -> GVariantSignature -> Bool
compare :: GVariantSignature -> GVariantSignature -> Ordering
$ccompare :: GVariantSignature -> GVariantSignature -> Ordering
Ord, GVariantSignature -> GVariantSignature -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GVariantSignature -> GVariantSignature -> Bool
$c/= :: GVariantSignature -> GVariantSignature -> Bool
== :: GVariantSignature -> GVariantSignature -> Bool
$c== :: GVariantSignature -> GVariantSignature -> Bool
Eq, Int -> GVariantSignature -> ShowS
[GVariantSignature] -> ShowS
GVariantSignature -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [GVariantSignature] -> ShowS
$cshowList :: [GVariantSignature] -> ShowS
show :: GVariantSignature -> [Char]
$cshow :: GVariantSignature -> [Char]
showsPrec :: Int -> GVariantSignature -> ShowS
$cshowsPrec :: Int -> GVariantSignature -> ShowS
Show)
newGVariantSignature :: Text -> Maybe GVariantSignature
newGVariantSignature :: Text -> Maybe GVariantSignature
newGVariantSignature Text
p = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$
forall a. Text -> (CString -> IO a) -> IO a
withTextCString Text
p forall a b. (a -> b) -> a -> b
$ \CString
cstr -> do
Bool
isSignature <- forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CString -> IO Int32
g_variant_is_signature CString
cstr
if Bool
isSignature
then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (Text -> GVariantSignature
GVariantSignature Text
p)
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
gvariantSignatureToText :: GVariantSignature -> Text
gvariantSignatureToText :: GVariantSignature -> Text
gvariantSignatureToText (GVariantSignature Text
p) = Text
p
instance IsGVariant GVariantSignature where
toGVariant :: GVariantSignature -> IO GVariant
toGVariant = GVariantSignature -> IO GVariant
gvariantFromSignature
fromGVariant :: GVariant -> IO (Maybe GVariantSignature)
fromGVariant = GVariant -> IO (Maybe Text)
gvariantToSignature forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> GVariantSignature
GVariantSignature forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)
toGVariantFormatString :: GVariantSignature -> Text
toGVariantFormatString GVariantSignature
_ = Text
"g"
instance IsGVariantBasicType GVariantSignature
foreign import ccall "g_variant_new_signature" new_signature
:: CString -> IO (Ptr GVariant)
gvariantFromSignature :: GVariantSignature -> IO GVariant
gvariantFromSignature :: GVariantSignature -> IO GVariant
gvariantFromSignature (GVariantSignature Text
p) =
forall a. Text -> (CString -> IO a) -> IO a
withTextCString Text
p forall a b. (a -> b) -> a -> b
$ CString -> IO (Ptr GVariant)
new_signature forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
gvariantToSignature :: GVariant -> IO (Maybe Text)
gvariantToSignature :: GVariant -> IO (Maybe Text)
gvariantToSignature =
forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType (forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: GVariantSignature))
forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO CString
get_string forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> HasCallStack => CString -> IO Text
cstringToText
instance IsGVariant GVariant where
toGVariant :: GVariant -> IO GVariant
toGVariant = GVariant -> IO GVariant
gvariantFromGVariant
fromGVariant :: GVariant -> IO (Maybe GVariant)
fromGVariant = GVariant -> IO (Maybe GVariant)
gvariantToGVariant
toGVariantFormatString :: GVariant -> Text
toGVariantFormatString GVariant
_ = Text
"v"
foreign import ccall "g_variant_new_variant" new_variant
:: Ptr GVariant -> IO (Ptr GVariant)
gvariantFromGVariant :: GVariant -> IO GVariant
gvariantFromGVariant :: GVariant -> IO GVariant
gvariantFromGVariant GVariant
v = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GVariant
v forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO (Ptr GVariant)
new_variant forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
foreign import ccall "g_variant_get_variant" get_variant
:: Ptr GVariant -> IO (Ptr GVariant)
gvariantToGVariant :: GVariant -> IO (Maybe GVariant)
gvariantToGVariant :: GVariant -> IO (Maybe GVariant)
gvariantToGVariant = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> IO (Ptr GVariant)
get_variant forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr
instance IsGVariant ByteString where
toGVariant :: ByteString -> IO GVariant
toGVariant = ByteString -> IO GVariant
gvariantFromBytestring
fromGVariant :: GVariant -> IO (Maybe ByteString)
fromGVariant = GVariant -> IO (Maybe ByteString)
gvariantToBytestring
toGVariantFormatString :: ByteString -> Text
toGVariantFormatString ByteString
_ = Text
"ay"
foreign import ccall "g_variant_get_bytestring" get_bytestring
:: Ptr GVariant -> IO CString
gvariantToBytestring :: GVariant -> IO (Maybe ByteString)
gvariantToBytestring :: GVariant -> IO (Maybe ByteString)
gvariantToBytestring = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck (Ptr GVariant -> IO CString
get_bytestring forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> HasCallStack => CString -> IO ByteString
cstringToByteString)
foreign import ccall "g_variant_new_bytestring" new_bytestring
:: CString -> IO (Ptr GVariant)
gvariantFromBytestring :: ByteString -> IO GVariant
gvariantFromBytestring :: ByteString -> IO GVariant
gvariantFromBytestring ByteString
bs = Ptr GVariant -> IO GVariant
wrapGVariantPtr forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
forall a. ByteString -> (CString -> IO a) -> IO a
B.useAsCString ByteString
bs CString -> IO (Ptr GVariant)
new_bytestring
foreign import ccall "g_variant_n_children" g_variant_n_children
:: Ptr GVariant -> IO Word64
{-# LINE 629 "Data/GI/Base/GVariant.hsc" #-}
foreign import ccall "g_variant_get_child_value" g_variant_get_child_value
:: Ptr GVariant -> Word64 -> IO (Ptr GVariant)
{-# LINE 632 "Data/GI/Base/GVariant.hsc" #-}
gvariant_get_children :: (Ptr GVariant) -> IO [GVariant]
gvariant_get_children :: Ptr GVariant -> IO [GVariant]
gvariant_get_children Ptr GVariant
vptr = do
Word64
n_children <- Ptr GVariant -> IO Word64
g_variant_n_children Ptr GVariant
vptr
if Word64
n_children forall a. Eq a => a -> a -> Bool
/= Word64
0
then forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((Ptr GVariant -> Word64 -> IO (Ptr GVariant)
g_variant_get_child_value Ptr GVariant
vptr) forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr)
[Word64
0..(Word64
n_childrenforall a. Num a => a -> a -> a
-Word64
1)]
else forall (m :: * -> *) a. Monad m => a -> m a
return []
instance IsGVariant a => IsGVariant (Maybe a) where
toGVariant :: Maybe a -> IO GVariant
toGVariant = forall a. IsGVariant a => Maybe a -> IO GVariant
gvariantFromMaybe
fromGVariant :: GVariant -> IO (Maybe (Maybe a))
fromGVariant = forall a. IsGVariant a => GVariant -> IO (Maybe (Maybe a))
gvariantToMaybe
toGVariantFormatString :: Maybe a -> Text
toGVariantFormatString Maybe a
_ = Text
"m" forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
foreign import ccall "g_variant_new_maybe" g_variant_new_maybe ::
Ptr GVariantType -> Ptr GVariant -> IO (Ptr GVariant)
gvariantFromMaybe :: forall a. IsGVariant a => Maybe a -> IO GVariant
gvariantFromMaybe :: forall a. IsGVariant a => Maybe a -> IO GVariant
gvariantFromMaybe Maybe a
m = do
let fmt :: Text
fmt = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall a. Text -> (Ptr GVariantType -> IO a) -> IO a
withGVariantType Text
fmt forall a b. (a -> b) -> a -> b
$ \Ptr GVariantType
tPtr ->
case Maybe a
m of
Just a
child -> do
GVariant
childVariant <- forall a. IsGVariant a => a -> IO GVariant
toGVariant a
child
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GVariant
childVariant
(Ptr GVariantType -> Ptr GVariant -> IO (Ptr GVariant)
g_variant_new_maybe Ptr GVariantType
tPtr forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Ptr GVariant -> IO GVariant
wrapGVariantPtr)
Maybe a
Nothing -> Ptr GVariantType -> Ptr GVariant -> IO (Ptr GVariant)
g_variant_new_maybe Ptr GVariantType
tPtr forall a. Ptr a
nullPtr forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ptr GVariant -> IO GVariant
wrapGVariantPtr
gvariantToMaybe :: forall a. IsGVariant a => GVariant -> IO (Maybe (Maybe a))
gvariantToMaybe :: forall a. IsGVariant a => GVariant -> IO (Maybe (Maybe a))
gvariantToMaybe GVariant
v = do
let fmt :: Text
fmt = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: Maybe a)
forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
fmt Ptr GVariant -> IO [GVariant]
gvariant_get_children GVariant
v forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
\case
Just [] -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just forall a. Maybe a
Nothing)
Just [GVariant
child] -> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
child forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
\case
Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
Just a
result -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just (forall a. a -> Maybe a
Just a
result))
Just [GVariant]
_ -> forall a. HasCallStack => [Char] -> a
error [Char]
"gvariantToMaybe :: the impossible happened, this is a bug."
Maybe [GVariant]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
data GVariantDictEntry key value = GVariantDictEntry key value
deriving (GVariantDictEntry key value -> GVariantDictEntry key value -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall key value.
(Eq key, Eq value) =>
GVariantDictEntry key value -> GVariantDictEntry key value -> Bool
/= :: GVariantDictEntry key value -> GVariantDictEntry key value -> Bool
$c/= :: forall key value.
(Eq key, Eq value) =>
GVariantDictEntry key value -> GVariantDictEntry key value -> Bool
== :: GVariantDictEntry key value -> GVariantDictEntry key value -> Bool
$c== :: forall key value.
(Eq key, Eq value) =>
GVariantDictEntry key value -> GVariantDictEntry key value -> Bool
Eq, Int -> GVariantDictEntry key value -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
forall key value.
(Show key, Show value) =>
Int -> GVariantDictEntry key value -> ShowS
forall key value.
(Show key, Show value) =>
[GVariantDictEntry key value] -> ShowS
forall key value.
(Show key, Show value) =>
GVariantDictEntry key value -> [Char]
showList :: [GVariantDictEntry key value] -> ShowS
$cshowList :: forall key value.
(Show key, Show value) =>
[GVariantDictEntry key value] -> ShowS
show :: GVariantDictEntry key value -> [Char]
$cshow :: forall key value.
(Show key, Show value) =>
GVariantDictEntry key value -> [Char]
showsPrec :: Int -> GVariantDictEntry key value -> ShowS
$cshowsPrec :: forall key value.
(Show key, Show value) =>
Int -> GVariantDictEntry key value -> ShowS
Show)
instance (IsGVariant a, IsGVariantBasicType a, IsGVariant b) =>
IsGVariant (GVariantDictEntry a b) where
toGVariant :: GVariantDictEntry a b -> IO GVariant
toGVariant (GVariantDictEntry a
key b
value) =
forall key value.
(IsGVariant key, IsGVariantBasicType key, IsGVariant value) =>
key -> value -> IO GVariant
gvariantFromDictEntry a
key b
value
fromGVariant :: GVariant -> IO (Maybe (GVariantDictEntry a b))
fromGVariant GVariant
gv =
((forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall key value. key -> value -> GVariantDictEntry key value
GVariantDictEntry) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall key value.
(IsGVariant key, IsGVariantBasicType key, IsGVariant value) =>
GVariant -> IO (Maybe (key, value))
gvariantToDictEntry GVariant
gv
toGVariantFormatString :: GVariantDictEntry a b -> Text
toGVariantFormatString GVariantDictEntry a b
_ = Text
"{"
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: b)
forall a. Semigroup a => a -> a -> a
<> Text
"}"
foreign import ccall "g_variant_new_dict_entry" g_variant_new_dict_entry ::
Ptr GVariant -> Ptr GVariant -> IO (Ptr GVariant)
gvariantFromDictEntry :: (IsGVariant key, IsGVariantBasicType key,
IsGVariant value) =>
key -> value -> IO GVariant
gvariantFromDictEntry :: forall key value.
(IsGVariant key, IsGVariantBasicType key, IsGVariant value) =>
key -> value -> IO GVariant
gvariantFromDictEntry key
key value
value = do
GVariant
keyVar <- forall a. IsGVariant a => a -> IO GVariant
toGVariant key
key
GVariant
valueVar <- forall a. IsGVariant a => a -> IO GVariant
toGVariant value
value
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GVariant
keyVar forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
keyPtr ->
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr GVariant
valueVar forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
valuePtr ->
Ptr GVariant -> Ptr GVariant -> IO (Ptr GVariant)
g_variant_new_dict_entry Ptr GVariant
keyPtr Ptr GVariant
valuePtr forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ptr GVariant -> IO GVariant
wrapGVariantPtr
gvariantToDictEntry :: forall key value.
(IsGVariant key, IsGVariantBasicType key,
IsGVariant value) =>
GVariant -> IO (Maybe (key, value))
gvariantToDictEntry :: forall key value.
(IsGVariant key, IsGVariantBasicType key, IsGVariant value) =>
GVariant -> IO (Maybe (key, value))
gvariantToDictEntry =
forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
fmt forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
varPtr -> do
[GVariant
key, GVariant
value] <- Ptr GVariant -> IO [GVariant]
gvariant_get_children Ptr GVariant
varPtr
(,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. IsGVariant a => GVariant -> IO a
unsafeFromGVariant GVariant
key forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO a
unsafeFromGVariant GVariant
value
where
fmt :: Text
fmt = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: GVariantDictEntry key value)
instance (IsGVariant a, IsGVariantBasicType a, IsGVariant b) =>
IsGVariant (M.Map a b) where
toGVariant :: Map a b -> IO GVariant
toGVariant = forall a b.
(IsGVariant a, IsGVariantBasicType a, IsGVariant b) =>
Map a b -> IO GVariant
gvariantFromMap
fromGVariant :: GVariant -> IO (Maybe (Map a b))
fromGVariant = forall a b.
(IsGVariant a, IsGVariantBasicType a, IsGVariant b) =>
GVariant -> IO (Maybe (Map a b))
gvariantToMap
toGVariantFormatString :: Map a b -> Text
toGVariantFormatString Map a b
_ = Text
"a{"
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: b)
forall a. Semigroup a => a -> a -> a
<> Text
"}"
gvariantFromMap :: (IsGVariant key, IsGVariantBasicType key,
IsGVariant value) =>
M.Map key value -> IO GVariant
gvariantFromMap :: forall a b.
(IsGVariant a, IsGVariantBasicType a, IsGVariant b) =>
Map a b -> IO GVariant
gvariantFromMap Map key value
m = forall a. IsGVariant a => [a] -> IO GVariant
gvariantFromList forall a b. (a -> b) -> a -> b
$
forall a b. (a -> b) -> [a] -> [b]
map (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall key value. key -> value -> GVariantDictEntry key value
GVariantDictEntry) (forall k a. Map k a -> [(k, a)]
M.toList Map key value
m)
gvariantToMap :: forall key value.
(IsGVariant key, IsGVariantBasicType key,
IsGVariant value) =>
GVariant -> IO (Maybe (M.Map key value))
gvariantToMap :: forall a b.
(IsGVariant a, IsGVariantBasicType a, IsGVariant b) =>
GVariant -> IO (Maybe (Map a b))
gvariantToMap = forall a. IsGVariant a => GVariant -> IO (Maybe [a])
gvariantToList forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([GVariantDictEntry key value] -> Map key value
fromDictEntryList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>))
where fromDictEntryList :: [GVariantDictEntry key value] ->
M.Map key value
fromDictEntryList :: [GVariantDictEntry key value] -> Map key value
fromDictEntryList = forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (a -> b) -> [a] -> [b]
map GVariantDictEntry key value -> (key, value)
tuplefy)
tuplefy :: GVariantDictEntry key value -> (key, value)
tuplefy :: GVariantDictEntry key value -> (key, value)
tuplefy (GVariantDictEntry key
key value
value) = (key
key, value
value)
instance IsGVariant a => IsGVariant [a] where
toGVariant :: [a] -> IO GVariant
toGVariant = forall a. IsGVariant a => [a] -> IO GVariant
gvariantFromList
fromGVariant :: GVariant -> IO (Maybe [a])
fromGVariant = forall a. IsGVariant a => GVariant -> IO (Maybe [a])
gvariantToList
toGVariantFormatString :: [a] -> Text
toGVariantFormatString [a]
_ = Text
"a" forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
foreign import ccall "g_variant_new_array" g_variant_new_array ::
Ptr GVariantType -> Ptr (Ptr GVariant) -> Word64 -> IO (Ptr GVariant)
{-# LINE 774 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromList :: forall a. IsGVariant a => [a] -> IO GVariant
gvariantFromList :: forall a. IsGVariant a => [a] -> IO GVariant
gvariantFromList [a]
children = do
let fmt :: Text
fmt = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. IsGVariant a => a -> IO GVariant
toGVariant [a]
children forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[GVariant]
childVariants ->
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
[a] -> ([Ptr a] -> IO c) -> IO c
withManagedPtrList [GVariant]
childVariants forall a b. (a -> b) -> a -> b
$ \[Ptr GVariant]
childrenPtrs -> do
forall a. Text -> (Ptr GVariantType -> IO a) -> IO a
withGVariantType Text
fmt forall a b. (a -> b) -> a -> b
$ \Ptr GVariantType
childType -> do
Ptr (Ptr GVariant)
packed <- forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr GVariant]
childrenPtrs
Ptr GVariant
result <- Ptr GVariantType
-> Ptr (Ptr GVariant) -> Word64 -> IO (Ptr GVariant)
g_variant_new_array Ptr GVariantType
childType Ptr (Ptr GVariant)
packed
(forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
children)
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
packed
Ptr GVariant -> IO GVariant
wrapGVariantPtr Ptr GVariant
result
gvariantToList :: forall a. IsGVariant a => GVariant -> IO (Maybe [a])
gvariantToList :: forall a. IsGVariant a => GVariant -> IO (Maybe [a])
gvariantToList = forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType (forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: [a]))
(Ptr GVariant -> IO [GVariant]
gvariant_get_children forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. IsGVariant a => GVariant -> IO a
unsafeFromGVariant)
foreign import ccall "g_variant_new_tuple" g_variant_new_tuple
:: Ptr (Ptr GVariant) -> Word64 -> IO (Ptr GVariant)
{-# LINE 796 "Data/GI/Base/GVariant.hsc" #-}
gvariantFromTuple :: [GVariant] -> IO GVariant
gvariantFromTuple :: [GVariant] -> IO GVariant
gvariantFromTuple [GVariant]
children =
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
[a] -> ([Ptr a] -> IO c) -> IO c
withManagedPtrList [GVariant]
children forall a b. (a -> b) -> a -> b
$ \[Ptr GVariant]
childrenPtrs -> do
Ptr (Ptr GVariant)
packed <- forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr GVariant]
childrenPtrs
Ptr GVariant
result <- Ptr (Ptr GVariant) -> Word64 -> IO (Ptr GVariant)
g_variant_new_tuple Ptr (Ptr GVariant)
packed (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length [GVariant]
children)
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
packed
Ptr GVariant -> IO GVariant
wrapGVariantPtr Ptr GVariant
result
gvariantToTuple :: GVariant -> IO (Maybe [GVariant])
gvariantToTuple :: GVariant -> IO (Maybe [GVariant])
gvariantToTuple = forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
"r" Ptr GVariant -> IO [GVariant]
gvariant_get_children
instance IsGVariant () where
toGVariant :: () -> IO GVariant
toGVariant ()
_ = [GVariant] -> IO GVariant
gvariantFromTuple []
fromGVariant :: GVariant -> IO (Maybe ())
fromGVariant = forall a.
IsGVariant a =>
(Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withTypeCheck (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ())
toGVariantFormatString :: () -> Text
toGVariantFormatString ()
_ = Text
"()"
instance IsGVariant a => IsGVariant (GVariantSinglet a) where
toGVariant :: GVariantSinglet a -> IO GVariant
toGVariant (GVariantSinglet a
s) = forall a. IsGVariant a => a -> IO GVariant
gvariantFromSinglet a
s
fromGVariant :: GVariant -> IO (Maybe (GVariantSinglet a))
fromGVariant = forall a. IsGVariant a => GVariant -> IO (Maybe a)
gvariantToSinglet forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> GVariantSinglet a
GVariantSinglet forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)
toGVariantFormatString :: GVariantSinglet a -> Text
toGVariantFormatString GVariantSinglet a
_ = Text
"("
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall a. Semigroup a => a -> a -> a
<> Text
")"
gvariantFromSinglet :: IsGVariant a => a -> IO GVariant
gvariantFromSinglet :: forall a. IsGVariant a => a -> IO GVariant
gvariantFromSinglet a
s = do
GVariant
sv <- forall a. IsGVariant a => a -> IO GVariant
toGVariant a
s
[GVariant] -> IO GVariant
gvariantFromTuple [GVariant
sv]
gvariantToSinglet :: forall a. IsGVariant a => GVariant -> IO (Maybe a)
gvariantToSinglet :: forall a. IsGVariant a => GVariant -> IO (Maybe a)
gvariantToSinglet = forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
fmt
(Ptr GVariant -> IO [GVariant]
gvariant_get_children
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a. IsGVariant a => GVariant -> IO a
unsafeFromGVariant)
where fmt :: Text
fmt = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: GVariantSinglet a)
instance (IsGVariant a, IsGVariant b) => IsGVariant (a,b) where
toGVariant :: (a, b) -> IO GVariant
toGVariant = forall a b. (IsGVariant a, IsGVariant b) => (a, b) -> IO GVariant
gvariantFromTwoTuple
fromGVariant :: GVariant -> IO (Maybe (a, b))
fromGVariant = forall a b.
(IsGVariant a, IsGVariant b) =>
GVariant -> IO (Maybe (a, b))
gvariantToTwoTuple
toGVariantFormatString :: (a, b) -> Text
toGVariantFormatString (a, b)
_ = Text
"("
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: b)
forall a. Semigroup a => a -> a -> a
<> Text
")"
gvariantFromTwoTuple :: (IsGVariant a, IsGVariant b) =>
(a,b) -> IO GVariant
gvariantFromTwoTuple :: forall a b. (IsGVariant a, IsGVariant b) => (a, b) -> IO GVariant
gvariantFromTwoTuple (a
a, b
b) = do
GVariant
va <- forall a. IsGVariant a => a -> IO GVariant
toGVariant a
a
GVariant
vb <- forall a. IsGVariant a => a -> IO GVariant
toGVariant b
b
[GVariant] -> IO GVariant
gvariantFromTuple [GVariant
va, GVariant
vb]
gvariantToTwoTuple :: forall a b. (IsGVariant a, IsGVariant b) =>
GVariant -> IO (Maybe (a,b))
gvariantToTwoTuple :: forall a b.
(IsGVariant a, IsGVariant b) =>
GVariant -> IO (Maybe (a, b))
gvariantToTwoTuple GVariant
variant = do
let expectedType :: Text
expectedType = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: (a,b))
Maybe [GVariant]
maybeChildren <- forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
expectedType Ptr GVariant -> IO [GVariant]
gvariant_get_children GVariant
variant
case Maybe [GVariant]
maybeChildren of
Just [GVariant
a1,GVariant
a2] -> do
(Maybe a
ma1, Maybe b
ma2) <- (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a2
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if forall a. Maybe a -> Bool
isJust Maybe a
ma1 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe b
ma2
then forall a. a -> Maybe a
Just (forall a. HasCallStack => Maybe a -> a
fromJust Maybe a
ma1, forall a. HasCallStack => Maybe a -> a
fromJust Maybe b
ma2)
else forall a. Maybe a
Nothing
Just [GVariant]
_ -> forall a. HasCallStack => [Char] -> a
error [Char]
"gvariantToTwoTuple :: the impossible happened, this is a bug."
Maybe [GVariant]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
instance (IsGVariant a, IsGVariant b, IsGVariant c) => IsGVariant (a,b,c) where
toGVariant :: (a, b, c) -> IO GVariant
toGVariant = forall a b c.
(IsGVariant a, IsGVariant b, IsGVariant c) =>
(a, b, c) -> IO GVariant
gvariantFromThreeTuple
fromGVariant :: GVariant -> IO (Maybe (a, b, c))
fromGVariant = forall a b c.
(IsGVariant a, IsGVariant b, IsGVariant c) =>
GVariant -> IO (Maybe (a, b, c))
gvariantToThreeTuple
toGVariantFormatString :: (a, b, c) -> Text
toGVariantFormatString (a, b, c)
_ = Text
"("
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: b)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: c)
forall a. Semigroup a => a -> a -> a
<> Text
")"
gvariantFromThreeTuple :: (IsGVariant a, IsGVariant b, IsGVariant c) =>
(a,b,c) -> IO GVariant
gvariantFromThreeTuple :: forall a b c.
(IsGVariant a, IsGVariant b, IsGVariant c) =>
(a, b, c) -> IO GVariant
gvariantFromThreeTuple (a
a, b
b, c
c) = do
GVariant
va <- forall a. IsGVariant a => a -> IO GVariant
toGVariant a
a
GVariant
vb <- forall a. IsGVariant a => a -> IO GVariant
toGVariant b
b
GVariant
vc <- forall a. IsGVariant a => a -> IO GVariant
toGVariant c
c
[GVariant] -> IO GVariant
gvariantFromTuple [GVariant
va, GVariant
vb, GVariant
vc]
gvariantToThreeTuple :: forall a b c. (IsGVariant a, IsGVariant b,
IsGVariant c) =>
GVariant -> IO (Maybe (a,b,c))
gvariantToThreeTuple :: forall a b c.
(IsGVariant a, IsGVariant b, IsGVariant c) =>
GVariant -> IO (Maybe (a, b, c))
gvariantToThreeTuple GVariant
variant = do
let expectedType :: Text
expectedType = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: (a,b,c))
Maybe [GVariant]
maybeChildren <- forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
expectedType Ptr GVariant -> IO [GVariant]
gvariant_get_children GVariant
variant
case Maybe [GVariant]
maybeChildren of
Just [GVariant
a1,GVariant
a2,GVariant
a3] -> do
(Maybe a
ma1, Maybe b
ma2, Maybe c
ma3) <- (,,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a1
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a2
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a3
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if forall a. Maybe a -> Bool
isJust Maybe a
ma1 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe b
ma2 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe c
ma3
then forall a. a -> Maybe a
Just (forall a. HasCallStack => Maybe a -> a
fromJust Maybe a
ma1, forall a. HasCallStack => Maybe a -> a
fromJust Maybe b
ma2, forall a. HasCallStack => Maybe a -> a
fromJust Maybe c
ma3)
else forall a. Maybe a
Nothing
Just [GVariant]
_ -> forall a. HasCallStack => [Char] -> a
error [Char]
"gvariantToThreeTuple :: the impossible happened, this is a bug."
Maybe [GVariant]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
instance (IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d) =>
IsGVariant (a,b,c,d) where
toGVariant :: (a, b, c, d) -> IO GVariant
toGVariant = forall a b c d.
(IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d) =>
(a, b, c, d) -> IO GVariant
gvariantFromFourTuple
fromGVariant :: GVariant -> IO (Maybe (a, b, c, d))
fromGVariant = forall a b c d.
(IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d) =>
GVariant -> IO (Maybe (a, b, c, d))
gvariantToFourTuple
toGVariantFormatString :: (a, b, c, d) -> Text
toGVariantFormatString (a, b, c, d)
_ = Text
"("
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: b)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: c)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: d)
forall a. Semigroup a => a -> a -> a
<> Text
")"
gvariantFromFourTuple :: (IsGVariant a, IsGVariant b, IsGVariant c,
IsGVariant d) => (a,b,c,d) -> IO GVariant
gvariantFromFourTuple :: forall a b c d.
(IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d) =>
(a, b, c, d) -> IO GVariant
gvariantFromFourTuple (a
a, b
b, c
c, d
d) = do
GVariant
va <- forall a. IsGVariant a => a -> IO GVariant
toGVariant a
a
GVariant
vb <- forall a. IsGVariant a => a -> IO GVariant
toGVariant b
b
GVariant
vc <- forall a. IsGVariant a => a -> IO GVariant
toGVariant c
c
GVariant
vd <- forall a. IsGVariant a => a -> IO GVariant
toGVariant d
d
[GVariant] -> IO GVariant
gvariantFromTuple [GVariant
va, GVariant
vb, GVariant
vc, GVariant
vd]
gvariantToFourTuple :: forall a b c d. (IsGVariant a, IsGVariant b,
IsGVariant c, IsGVariant d) =>
GVariant -> IO (Maybe (a,b,c,d))
gvariantToFourTuple :: forall a b c d.
(IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d) =>
GVariant -> IO (Maybe (a, b, c, d))
gvariantToFourTuple GVariant
variant = do
let expectedType :: Text
expectedType = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: (a,b,c,d))
Maybe [GVariant]
maybeChildren <- forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
expectedType Ptr GVariant -> IO [GVariant]
gvariant_get_children GVariant
variant
case Maybe [GVariant]
maybeChildren of
Just [GVariant
a1,GVariant
a2,GVariant
a3,GVariant
a4] -> do
(Maybe a
ma1, Maybe b
ma2, Maybe c
ma3,Maybe d
ma4) <- (,,,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a1
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a2
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a3
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a4
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if forall a. Maybe a -> Bool
isJust Maybe a
ma1 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe b
ma2 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe c
ma3 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe d
ma4
then forall a. a -> Maybe a
Just (forall a. HasCallStack => Maybe a -> a
fromJust Maybe a
ma1, forall a. HasCallStack => Maybe a -> a
fromJust Maybe b
ma2, forall a. HasCallStack => Maybe a -> a
fromJust Maybe c
ma3, forall a. HasCallStack => Maybe a -> a
fromJust Maybe d
ma4)
else forall a. Maybe a
Nothing
Just [GVariant]
_ -> forall a. HasCallStack => [Char] -> a
error [Char]
"gvariantToFourTuple :: the impossible happened, this is a bug."
Maybe [GVariant]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
instance (IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d, IsGVariant e)
=> IsGVariant (a,b,c,d,e) where
toGVariant :: (a, b, c, d, e) -> IO GVariant
toGVariant = forall a b c d e.
(IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d,
IsGVariant e) =>
(a, b, c, d, e) -> IO GVariant
gvariantFromFiveTuple
fromGVariant :: GVariant -> IO (Maybe (a, b, c, d, e))
fromGVariant = forall a b c d e.
(IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d,
IsGVariant e) =>
GVariant -> IO (Maybe (a, b, c, d, e))
gvariantToFiveTuple
toGVariantFormatString :: (a, b, c, d, e) -> Text
toGVariantFormatString (a, b, c, d, e)
_ = Text
"("
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: a)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: b)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: c)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: d)
forall a. Semigroup a => a -> a -> a
<> forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: e)
forall a. Semigroup a => a -> a -> a
<> Text
")"
gvariantFromFiveTuple :: (IsGVariant a, IsGVariant b, IsGVariant c,
IsGVariant d, IsGVariant e) =>
(a,b,c,d,e) -> IO GVariant
gvariantFromFiveTuple :: forall a b c d e.
(IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d,
IsGVariant e) =>
(a, b, c, d, e) -> IO GVariant
gvariantFromFiveTuple (a
a, b
b, c
c, d
d, e
e) = do
GVariant
va <- forall a. IsGVariant a => a -> IO GVariant
toGVariant a
a
GVariant
vb <- forall a. IsGVariant a => a -> IO GVariant
toGVariant b
b
GVariant
vc <- forall a. IsGVariant a => a -> IO GVariant
toGVariant c
c
GVariant
vd <- forall a. IsGVariant a => a -> IO GVariant
toGVariant d
d
GVariant
ve <- forall a. IsGVariant a => a -> IO GVariant
toGVariant e
e
[GVariant] -> IO GVariant
gvariantFromTuple [GVariant
va, GVariant
vb, GVariant
vc, GVariant
vd, GVariant
ve]
gvariantToFiveTuple :: forall a b c d e.
(IsGVariant a, IsGVariant b, IsGVariant c,
IsGVariant d, IsGVariant e) =>
GVariant -> IO (Maybe (a,b,c,d,e))
gvariantToFiveTuple :: forall a b c d e.
(IsGVariant a, IsGVariant b, IsGVariant c, IsGVariant d,
IsGVariant e) =>
GVariant -> IO (Maybe (a, b, c, d, e))
gvariantToFiveTuple GVariant
variant = do
let expectedType :: Text
expectedType = forall a. IsGVariant a => a -> Text
toGVariantFormatString (forall a. HasCallStack => a
undefined :: (a,b,c,d,e))
Maybe [GVariant]
maybeChildren <- forall a.
Text -> (Ptr GVariant -> IO a) -> GVariant -> IO (Maybe a)
withExplicitType Text
expectedType Ptr GVariant -> IO [GVariant]
gvariant_get_children GVariant
variant
case Maybe [GVariant]
maybeChildren of
Just [GVariant
a1,GVariant
a2,GVariant
a3,GVariant
a4,GVariant
a5] -> do
(Maybe a
ma1, Maybe b
ma2, Maybe c
ma3, Maybe d
ma4, Maybe e
ma5) <- (,,,,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a1
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a2
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a3
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a4
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. IsGVariant a => GVariant -> IO (Maybe a)
fromGVariant GVariant
a5
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if forall a. Maybe a -> Bool
isJust Maybe a
ma1 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe b
ma2 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe c
ma3 Bool -> Bool -> Bool
&&
forall a. Maybe a -> Bool
isJust Maybe d
ma4 Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isJust Maybe e
ma5
then forall a. a -> Maybe a
Just (forall a. HasCallStack => Maybe a -> a
fromJust Maybe a
ma1, forall a. HasCallStack => Maybe a -> a
fromJust Maybe b
ma2, forall a. HasCallStack => Maybe a -> a
fromJust Maybe c
ma3,
forall a. HasCallStack => Maybe a -> a
fromJust Maybe d
ma4, forall a. HasCallStack => Maybe a -> a
fromJust Maybe e
ma5)
else forall a. Maybe a
Nothing
Just [GVariant]
_ -> forall a. HasCallStack => [Char] -> a
error [Char]
"gvariantToFiveTuple :: the impossible happened, this is a bug."
Maybe [GVariant]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing