{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

#GVariantDict is a mutable interface to #GVariant dictionaries.

It can be used for doing a sequence of dictionary lookups in an
efficient way on an existing #GVariant dictionary or it can be used
to construct new dictionaries with a hashtable-like interface.  It
can also be used for taking existing dictionaries and modifying them
in order to create new ones.

#GVariantDict can only be used with %G_VARIANT_TYPE_VARDICT
dictionaries.

It is possible to use #GVariantDict allocated on the stack or on the
heap.  When using a stack-allocated #GVariantDict, you begin with a
call to g_variant_dict_init() and free the resources with a call to
g_variant_dict_clear().

Heap-allocated #GVariantDict follows normal refcounting rules: you
allocate it with g_variant_dict_new() and use g_variant_dict_ref()
and g_variant_dict_unref().

g_variant_dict_end() is used to convert the #GVariantDict back into a
dictionary-type #GVariant.  When used with stack-allocated instances,
this also implicitly frees all associated memory, but for
heap-allocated instances, you must still call g_variant_dict_unref()
afterwards.

You will typically want to use a heap-allocated #GVariantDict when
you expose it as part of an API.  For most other uses, the
stack-allocated form will be more convenient.

Consider the following two examples that do the same thing in each
style: take an existing dictionary and look up the "count" uint32
key, adding 1 to it if it is found, or returning an error if the
key is not found.  Each returns the new dictionary as a floating
#GVariant.

## Using a stack-allocated GVariantDict

|[<!-- language="C" -->
  GVariant *
  add_to_count (GVariant  *orig,
                GError   **error)
  {
    GVariantDict dict;
    guint32 count;

    g_variant_dict_init (&dict, orig);
    if (!g_variant_dict_lookup (&dict, "count", "u", &count))
      {
        g_set_error (...);
        g_variant_dict_clear (&dict);
        return NULL;
      }

    g_variant_dict_insert (&dict, "count", "u", count + 1);

    return g_variant_dict_end (&dict);
  }
]|

## Using heap-allocated GVariantDict

|[<!-- language="C" -->
  GVariant *
  add_to_count (GVariant  *orig,
                GError   **error)
  {
    GVariantDict *dict;
    GVariant *result;
    guint32 count;

    dict = g_variant_dict_new (orig);

    if (g_variant_dict_lookup (dict, "count", "u", &count))
      {
        g_variant_dict_insert (dict, "count", "u", count + 1);
        result = g_variant_dict_end (dict);
      }
    else
      {
        g_set_error (...);
        result = NULL;
      }

    g_variant_dict_unref (dict);

    return result;
  }
]|
-}

module GI.GLib.Structs.VariantDict
    ( 

-- * Exported types
    VariantDict(..)                         ,
    noVariantDict                           ,


 -- * Methods
-- ** variantDictClear
    variantDictClear                        ,


-- ** variantDictContains
    variantDictContains                     ,


-- ** variantDictEnd
    variantDictEnd                          ,


-- ** variantDictInsertValue
    variantDictInsertValue                  ,


-- ** variantDictLookupValue
    variantDictLookupValue                  ,


-- ** variantDictNew
    variantDictNew                          ,


-- ** variantDictRef
    variantDictRef                          ,


-- ** variantDictRemove
    variantDictRemove                       ,


-- ** variantDictUnref
    variantDictUnref                        ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.GLib.Types
import GI.GLib.Callbacks

newtype VariantDict = VariantDict (ForeignPtr VariantDict)
foreign import ccall "g_variant_dict_get_type" c_g_variant_dict_get_type :: 
    IO GType

instance BoxedObject VariantDict where
    boxedType _ = c_g_variant_dict_get_type

noVariantDict :: Maybe VariantDict
noVariantDict = Nothing

-- method VariantDict::new
-- method type : Constructor
-- Args : [Arg {argName = "from_asv", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "from_asv", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "GLib" "VariantDict"
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_new" g_variant_dict_new :: 
    Ptr GVariant ->                         -- from_asv : TVariant
    IO (Ptr VariantDict)


variantDictNew ::
    (MonadIO m) =>
    Maybe (GVariant) ->                     -- from_asv
    m VariantDict
variantDictNew from_asv = liftIO $ do
    maybeFrom_asv <- case from_asv of
        Nothing -> return nullPtr
        Just jFrom_asv -> do
            let jFrom_asv' = unsafeManagedPtrGetPtr jFrom_asv
            return jFrom_asv'
    result <- g_variant_dict_new maybeFrom_asv
    checkUnexpectedReturnNULL "g_variant_dict_new" result
    result' <- (wrapBoxed VariantDict) result
    return result'

-- method VariantDict::clear
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_clear" g_variant_dict_clear :: 
    Ptr VariantDict ->                      -- _obj : TInterface "GLib" "VariantDict"
    IO ()


variantDictClear ::
    (MonadIO m) =>
    VariantDict ->                          -- _obj
    m ()
variantDictClear _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    g_variant_dict_clear _obj'
    touchManagedPtr _obj
    return ()

-- method VariantDict::contains
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_contains" g_variant_dict_contains :: 
    Ptr VariantDict ->                      -- _obj : TInterface "GLib" "VariantDict"
    CString ->                              -- key : TBasicType TUTF8
    IO CInt


variantDictContains ::
    (MonadIO m) =>
    VariantDict ->                          -- _obj
    T.Text ->                               -- key
    m Bool
variantDictContains _obj key = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    key' <- textToCString key
    result <- g_variant_dict_contains _obj' key'
    let result' = (/= 0) result
    touchManagedPtr _obj
    freeMem key'
    return result'

-- method VariantDict::end
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TVariant
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_end" g_variant_dict_end :: 
    Ptr VariantDict ->                      -- _obj : TInterface "GLib" "VariantDict"
    IO (Ptr GVariant)


variantDictEnd ::
    (MonadIO m) =>
    VariantDict ->                          -- _obj
    m GVariant
variantDictEnd _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- g_variant_dict_end _obj'
    checkUnexpectedReturnNULL "g_variant_dict_end" result
    result' <- newGVariantFromPtr result
    touchManagedPtr _obj
    return result'

-- method VariantDict::insert_value
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_insert_value" g_variant_dict_insert_value :: 
    Ptr VariantDict ->                      -- _obj : TInterface "GLib" "VariantDict"
    CString ->                              -- key : TBasicType TUTF8
    Ptr GVariant ->                         -- value : TVariant
    IO ()


variantDictInsertValue ::
    (MonadIO m) =>
    VariantDict ->                          -- _obj
    T.Text ->                               -- key
    GVariant ->                             -- value
    m ()
variantDictInsertValue _obj key value = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    key' <- textToCString key
    let value' = unsafeManagedPtrGetPtr value
    g_variant_dict_insert_value _obj' key' value'
    touchManagedPtr _obj
    freeMem key'
    return ()

-- method VariantDict::lookup_value
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expected_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expected_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TVariant
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_lookup_value" g_variant_dict_lookup_value :: 
    Ptr VariantDict ->                      -- _obj : TInterface "GLib" "VariantDict"
    CString ->                              -- key : TBasicType TUTF8
    Ptr VariantType ->                      -- expected_type : TInterface "GLib" "VariantType"
    IO (Ptr GVariant)


variantDictLookupValue ::
    (MonadIO m) =>
    VariantDict ->                          -- _obj
    T.Text ->                               -- key
    Maybe (VariantType) ->                  -- expected_type
    m GVariant
variantDictLookupValue _obj key expected_type = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    key' <- textToCString key
    maybeExpected_type <- case expected_type of
        Nothing -> return nullPtr
        Just jExpected_type -> do
            let jExpected_type' = unsafeManagedPtrGetPtr jExpected_type
            return jExpected_type'
    result <- g_variant_dict_lookup_value _obj' key' maybeExpected_type
    checkUnexpectedReturnNULL "g_variant_dict_lookup_value" result
    result' <- wrapGVariantPtr result
    touchManagedPtr _obj
    whenJust expected_type touchManagedPtr
    freeMem key'
    return result'

-- method VariantDict::ref
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "GLib" "VariantDict"
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_ref" g_variant_dict_ref :: 
    Ptr VariantDict ->                      -- _obj : TInterface "GLib" "VariantDict"
    IO (Ptr VariantDict)


variantDictRef ::
    (MonadIO m) =>
    VariantDict ->                          -- _obj
    m VariantDict
variantDictRef _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- g_variant_dict_ref _obj'
    checkUnexpectedReturnNULL "g_variant_dict_ref" result
    result' <- (wrapBoxed VariantDict) result
    touchManagedPtr _obj
    return result'

-- method VariantDict::remove
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_remove" g_variant_dict_remove :: 
    Ptr VariantDict ->                      -- _obj : TInterface "GLib" "VariantDict"
    CString ->                              -- key : TBasicType TUTF8
    IO CInt


variantDictRemove ::
    (MonadIO m) =>
    VariantDict ->                          -- _obj
    T.Text ->                               -- key
    m Bool
variantDictRemove _obj key = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    key' <- textToCString key
    result <- g_variant_dict_remove _obj' key'
    let result' = (/= 0) result
    touchManagedPtr _obj
    freeMem key'
    return result'

-- method VariantDict::unref
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "GLib" "VariantDict", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "g_variant_dict_unref" g_variant_dict_unref :: 
    Ptr VariantDict ->                      -- _obj : TInterface "GLib" "VariantDict"
    IO ()


variantDictUnref ::
    (MonadIO m) =>
    VariantDict ->                          -- _obj
    m ()
variantDictUnref _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    g_variant_dict_unref _obj'
    touchManagedPtr _obj
    return ()