{-# LINE 1 "Data/GI/Base/GVariant.hsc" #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE EmptyDataDecls #-}
{-|
This module contains some helper functions for dealing with GVariant
values. The simplest way of dealing with them is by using the
'IsGVariant' typeclass:

> str <- fromGVariant variant :: IO (Maybe Text)

assuming that the variant is expected to contain a
string in UTF8 encoding. The code becomes even shorter if the type
checker can determine the return type for you:


> readStringVariant :: GVariant -> IO Text
> readStringVariant variant =
>   fromGVariant variant >>= \case
>      Nothing  -> error "Variant was not a string"
>      Just str -> return str

Alternatively, you can use manually the gvariantFrom* and
gvariantTo* family of functions.
-}
module Data.GI.Base.GVariant
    ( IsGVariant(..)
    , IsGVariantBasicType

    , noGVariant

    , gvariantGetTypeString

    -- * Type wrappers
    -- | Some 'GVariant' types are isomorphic to Haskell types, but they
    -- carry some extra information. For example, there is a tuple
    -- singlet type, which is isomorphic to a single Haskell value
    -- with the added bit of information that it is wrapped in a tuple
    -- container. In order to use these values you can use the
    -- following wrappers, which allow the 'IsGVariant' instance to
    -- disambiguate the requested type properly.

    , GVariantSinglet(GVariantSinglet)
    , GVariantDictEntry(GVariantDictEntry)
    , GVariantHandle(GVariantHandle)
    , GVariantObjectPath
    , newGVariantObjectPath
    , gvariantObjectPathToText
    , GVariantSignature
    , newGVariantSignature
    , gvariantSignatureToText

    -- * Manual memory management

    , wrapGVariantPtr
    , newGVariantFromPtr
    , unrefGVariant
    , disownGVariant

    -- * Manual conversions

    -- ** Basic types
    --
    -- | The use of these should be fairly self-explanatory. If you
    -- want to convert a Haskell type into a 'GVariant', use
    -- gvariantTo*. If you want to convert a 'GVariant' into a Haskell
    -- type, use gvariantFrom*. The conversion can fail if the
    -- 'GVariant' is not of the expected type (if you want to convert
    -- a 'GVariant' containing a 'Int16' into a 'Text' value, say), in
    -- which case 'Nothing' will be returned.
    , 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

    -- ** Container type conversions
    , 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)

-- | An alias for @Nothing :: Maybe GVariant@ to save some typing.
noGVariant :: Maybe GVariant
noGVariant :: Maybe GVariant
noGVariant = forall a. Maybe a
Nothing

-- | The typeclass for types that can be automatically marshalled into
-- 'GVariant' using 'toGVariant' and 'fromGVariant'.
class IsGVariant a where
    -- | Convert a value of the given type into a GVariant.
    toGVariant   :: a -> IO GVariant
    -- | Try to decode a 'GVariant' into a target type. If the
    -- conversion fails we return 'Nothing'. The type that was
    -- expected can be obtained by calling 'toGVariantFormatString',
    -- and the actual type as understood by the 'GVariant' code can be
    -- obtained by calling 'gvariantToTypeString'.
    fromGVariant :: GVariant -> IO (Maybe a)
    -- | The expected format string for this type (the argument is
    -- ignored).
    toGVariantFormatString :: a -> Text

-- Same as fromGVariant, for cases where we have checked that things
-- have the right type in advance.
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

-- | The typeclass for basic type 'GVariant' types, i.e. those that
-- are not containers.
class Ord a => IsGVariantBasicType a

-- | Haskell has no notion of one element tuples, but GVariants do, so
-- the following allows for marshalling one element tuples properly
-- using 'fromGVariant' and 'toGVariant'. For instance, to construct a
-- single element tuple containing a string, you could do
--
-- > toGVariant (GVariantSinglet "Test")
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

-- | Get the expected type of a 'GVariant', in 'GVariant'
-- notation. See
-- <https://developer.gnome.org/glib/stable/glib-GVariantType.html>
-- for the meaning of the resulting format string.
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 ())

-- | Take ownership of a passed in 'Ptr' (typically created just for
-- us, so if it is floating we sink it).
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

-- | Construct a Haskell wrapper for the given 'GVariant', without
-- assuming ownership.
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

-- | Remove a reference to the given 'GVariant'.
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

-- | Disown a `GVariant`, i.e. do not unref the underlying object when
-- the Haskell object is garbage collected.
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" #-}

-- | Convert a DBus handle (an 'Int32') into a 'GVariant'.
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" #-}

-- | Extract the DBus handle (an 'Int32') inside a 'GVariant'.
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

-- | Decode an UTF-8 encoded string 'GVariant' into 'Text'.
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)

-- | Encode a 'Text' into an UTF-8 encoded string '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" #-}

-- | An object representing a DBus object path, which is a particular
-- type of 'GVariant' too. (Just a string with some specific
-- requirements.) In order to construct/deconstruct a
-- 'GVariantObjectPath' one can use 'newGVariantObjectPath'
-- and 'gvariantObjectPathToText'.
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)

-- | Try to construct a DBus object path. If the passed string is not
-- a valid object path 'Nothing' will be returned.
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

-- | Return the 'Text' representation of a 'GVariantObjectPath'.
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)

-- | Construct a 'GVariant' containing an object path. In order to
-- build a 'GVariantObjectPath' value see 'newGVariantObjectPath'.
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

-- | Extract a 'GVariantObjectPath' from a 'GVariant', represented as
-- its underlying 'Text' representation.
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" #-}

-- | An object representing a DBus signature, which is a particular
-- type of 'GVariant' too. (Just a string with some specific
-- requirements.) In order to construct/deconstruct a
-- 'GVariantSignature' one can use 'newGVariantSignature' and
-- 'gvariantSignatureToText'.
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)

-- | Try to construct a DBus object path. If the passed string is not
-- a valid DBus signature 'Nothing' will be returned.
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

-- | Return the 'Text' representation of a 'GVariantSignature'.
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)

-- | Construct a 'GVariant' containing an DBus signature. In order to
-- build a 'GVariantSignature' value see 'newGVariantSignature'.
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

-- | Extract a 'GVariantSignature' from a 'GVariant', represented as
-- 'Text'.
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)

-- | Box a 'GVariant' inside another '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)

-- | Unbox a 'GVariant' contained inside another '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

-- | Extract a zero terminated list of bytes into a 'ByteString'.
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)

-- | Encode a 'ByteString' into a list of bytes '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" #-}

-- No type checking is done here, it is assumed that the caller knows
-- that the passed variant is indeed of a container type.
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
      -- n_children is an unsigned type (Word64 in 64 bit
      -- architectures), so if it is 0 and we substract one we would
      -- wrap around to 2^64-1.
      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)

-- | Convert a 'Maybe' value into a corresponding 'GVariant' of maybe
-- type.
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

-- | Try to decode a maybe 'GVariant' into the corresponding 'Maybe'
-- type. If the conversion is successful this returns @Just x@, where
-- @x@ itself is of 'Maybe' type. So, in particular, @Just Nothing@
-- indicates a successful call, and means that the GVariant of maybe
-- type was empty.
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

-- | A DictEntry 'GVariant' is isomorphic to a two-tuple. Wrapping the
-- values into a 'GVariantDictentry' allows the 'IsGVariant' instance
-- to do the right thing.
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)

-- | Construct a 'GVariant' of type DictEntry from the given 'key' and
-- 'value'. The key must be a basic 'GVariant' type, i.e. not a
-- container. This is determined by whether it belongs to the
-- 'IsGVariantBasicType' typeclass. On the other hand 'value' is an
-- arbitrary 'GVariant', and in particular it can be a container type.
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

-- | Unpack a DictEntry variant into 'key' and 'value', which are
-- returned as a two element tuple in case of success.
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
"}"

-- | Pack a 'Map' into a 'GVariant' for dictionary type, which is just
-- an array of 'GVariantDictEntry'.
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)

-- | Unpack a 'GVariant' into a 'M.Map'. Notice that this assumes that
-- all the elements in the 'GVariant' array of 'GVariantDictEntry' are
-- of the same type, which is not necessary for a generic 'GVariant',
-- so this is somewhat restrictive. For the general case it is
-- necessary to use 'gvariantToList' plus 'gvariantToDictEntry'
-- directly.
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" #-}

-- | Given a list of elements construct a 'GVariant' array containing
-- them.
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

-- | Unpack a 'GVariant' array into its elements.
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" #-}

-- | Given a list of 'GVariant', construct a 'GVariant' tuple
-- containing the elements in the list.
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

-- | Extract the children of a 'GVariant' tuple into a list.
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

-- | The empty tuple GVariant, mostly useful for type checking.
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
"()"

-- | One element tuples.
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