2003-04-08 Alexander Larsson <alexl@redhat.com>

	Implemented recursive types, named types and new-style iters

	* bus/driver.c:
	* glib/test-thread-client.c: (thread_func):
	* glib/test-thread-server.c: (handle_test_message):
	* test/test-service.c: (handle_echo):
	Update to new api

	* dbus/Makefile.am:
	* dbus/dbus-dict.c:
	* dbus/dbus-dict.h:
	* dbus/dbus.h
	Remove DBusDict

	* dbus/dbus-internals.c: (_dbus_type_to_string):
	Update for new types.

	* dbus/dbus-marshal.[ch]:
	Implement recursive types and the new marshalling format.
	Remove hardcoded dict marshalling.
	Marshal named types.

	* dbus/dbus-message-builder.c:
	Add BYTE_ARRAY.
	Remove references to old types

	* dbus/dbus-message.[ch]:
	New non-refcounted iter API that supports recursive iters.
	Use iters for appending, including support for recursive
	iters.
	Add byte and named type support.
	Update everything to new marshalling formats.
	Add tests for new API.

	* dbus/dbus-protocol.h:
	Remove old array types.
	Add types: BYTE, ARRAY, DICT, NAMED

	* dbus/dbus-string.c:
	* dbus/dbus-sysdeps.c:
	Make parse_double locale safe.

	* dbus/dbus-test-main.c:
	Call setlocale.

	* dbus/dbus-test.c:
	Kill dict test

	* doc/dbus-specification.sgml:
	Update spec

	* test/data/incomplete-messages/missing-body.message:
	* test/data/invalid-messages/bad-boolean.message:
	* test/data/invalid-messages/bad-boolean-array.message:
	* test/data/invalid-messages/boolean-array-length-too-long.message-raw:
	* test/data/invalid-messages/boolean-has-no-value.message-raw:
	* test/data/invalid-messages/too-short-dict.message:
	* test/data/valid-messages/dict-simple.message:
	* test/data/valid-messages/dict.message:
	* test/data/valid-messages/emptiness.message:
	* test/data/valid-messages/lots-of-arguments.message:
	* test/data/valid-messages/no-padding.message:
	* test/data/valid-messages/recursive-types.message:
	Add missing NAME fields
	Fix up dicts & arrays

	* test/data/invalid-messages/dict-with-nil-value.message:
	Removed, this is not invalid anymore.

	* test/data/valid-messages/recursive-types.message:
	Add new test for deeply recursive types.

1 files changed, 0 insertions, 1139 deletions

diff --git a/dbus/dbus-dict.c b/dbus/dbus-dict.c
deleted file mode 100644
index e19f9a65..00000000
--- a/dbus/dbus-dict.c
+++ /dev/null
@@ -1,1139 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu" -*- */
-/* dbus-dict.h Dict object for key-value data.
- * 
- * Copyright (C) 2003  CodeFactory AB
- *
- * Licensed under the Academic Free License version 1.2
- * 
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
-#include "dbus-dict.h"
-#include "dbus-hash.h"
-#include "dbus-internals.h"
-#include "dbus-protocol.h"
-
-/**
- * @defgroup DBusDict DBusDict
- * @ingroup DBus
- * @brief key/value data structure.
- *
- * A DBusDict is a data structure that can store and lookup different
- * values by name.
- *
- * @{
- */
-
-struct DBusDict
-{
-  int refcount;
-
-  DBusHashTable *table;
-};
-
-typedef struct
-{
-  int type;
-  union {
-    dbus_bool_t boolean_value;
-    dbus_int32_t int32_value;
-    dbus_uint32_t uint32_value;
-    double double_value;
-    char *string_value;
-    struct {
-      unsigned char *value;
-      int len;
-    } byte_array;
-    struct {
-      dbus_int32_t *value;
-      int len;
-    } int32_array;
-    struct {
-      dbus_uint32_t *value;
-      int len;
-    } uint32_array;
-    struct {
-      double *value;
-      int len;
-    } double_array;
-    struct {
-      char **value;
-      int len;
-    } string_array;
-  } v;
-} DBusDictEntry;
-
-static void
-dbus_dict_entry_free (DBusDictEntry *entry)
-{
-  if (!entry)
-    return;
-  
-  switch (entry->type)
-    {
-    case DBUS_TYPE_INVALID:
-    case DBUS_TYPE_BOOLEAN:
-    case DBUS_TYPE_INT32:
-    case DBUS_TYPE_UINT32:
-    case DBUS_TYPE_DOUBLE:
-      break;
-    case DBUS_TYPE_STRING:
-      dbus_free (entry->v.string_value);
-      break;
-    case DBUS_TYPE_BYTE_ARRAY:
-    case DBUS_TYPE_BOOLEAN_ARRAY:
-      dbus_free (entry->v.byte_array.value);
-      break;
-    case DBUS_TYPE_INT32_ARRAY:
-      dbus_free (entry->v.int32_array.value);
-      break;
-    case DBUS_TYPE_UINT32_ARRAY:
-      dbus_free (entry->v.uint32_array.value);
-      break;
-    case DBUS_TYPE_DOUBLE_ARRAY:
-      dbus_free (entry->v.uint32_array.value);
-      break;
-    case DBUS_TYPE_STRING_ARRAY:
-      dbus_free_string_array (entry->v.string_array.value);
-      break;
-    default:
-      _dbus_assert_not_reached ("Unknown or invalid dict entry type\n");
-    }
-
-  dbus_free (entry);
-}
-
-/**
- * Constructs a new DBusDict. Returns #NULL if memory can't be
- * allocated.
- *
- * @returns a new DBusDict or #NULL.
- */
-DBusDict *
-dbus_dict_new (void)
-{
-  DBusDict *dict;
-
-  dict = dbus_new0 (DBusDict, 1);
-
-  if (!dict)
-    return NULL;
-
-  dict->table = _dbus_hash_table_new (DBUS_HASH_STRING, dbus_free, (DBusFreeFunction)dbus_dict_entry_free);
-
-  if (!dict->table)
-    {
-      dbus_free (dict);
-      return NULL;
-    }
-  
-  dict->refcount = 1;
-  
-  return dict;
-}
-
-/**
- * Increments the reference count of a DBusDict.
- *
- * @param dict the dict.
- * @see dbus_dict_unref
- */
-void
-dbus_dict_ref (DBusDict *dict)
-{
-  dict->refcount += 1;
-  
-  _dbus_assert (dict->refcount > 1);
-}
-
-/**
- * Decrements the reference count of a DBusDict
- *
- * @param dict the dict
- * @see dbus_dict_ref
- */
-void
-dbus_dict_unref (DBusDict *dict)
-{
-  dict->refcount -= 1;
-
-  _dbus_assert (dict->refcount >= 0);
-
-  if (dict->refcount == 0)
-    {
-      _dbus_hash_table_unref (dict->table);
-      dbus_free (dict);
-    }
-}
-
-/**
- * Checks if the dict contains the specified key.
- *
- * @param dict the dict.
- * @param key the key
- * @returns #TRUE if the dict contains the specified key.
- */
-dbus_bool_t
-dbus_dict_contains (DBusDict   *dict,
-		    const char *key)
-{
-  return (_dbus_hash_table_lookup_string (dict->table, key) != NULL);
-}
-
-/**
- * Removes the dict entry for the given key. If no dict entry for the
- * key exists, this function does nothing.
- *
- * @param dict the dict
- * @param key the key
- * @returns #TRUE if the entry existed
- */
-dbus_bool_t
-dbus_dict_remove (DBusDict   *dict,
-		  const char *key)
-{
-  return _dbus_hash_table_remove_string (dict->table, key);
-}
-
-/**
- * Returns the type of the value in the dict entry specified by the key.
- *
- * @param dict the dict
- * @param key the key
- * @returns the value type or DBUS_TYPE_NIL if the key wasn't found.
- */
-int
-dbus_dict_get_value_type (DBusDict   *dict,
-			  const char *key)
-{
-  DBusDictEntry *entry;
-
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-
-  if (!entry)
-    return DBUS_TYPE_NIL;
-  else
-    return entry->type;
-}
-
-/**
- * Returns the keys in the dict as a string array.
- *
- * @param dict the dict
- * @param keys return location for string array
- * @param len return location for string array length
- * ®returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_get_keys (DBusDict *dict,
-		    char   ***keys,
-		    int      *len)
-{
-  int size, i;
-  char **tmp;
-  char *key;
-  DBusHashIter iter;
-  
-  size = _dbus_hash_table_get_n_entries (dict->table);
-  *len = size;
-  
-  if (size == 0)
-    {
-      *keys = NULL;
-      return TRUE;
-    }
-
-  tmp = dbus_new0 (char *, size + 1);
-  if (!tmp)
-    return FALSE;
-
-  
-  i = 0;
-  _dbus_hash_iter_init (dict->table, &iter);
-
-  while (_dbus_hash_iter_next (&iter))
-    {
-      key = _dbus_strdup (_dbus_hash_iter_get_string_key (&iter));
-
-      if (!key)
-	{
-	  dbus_free_string_array (tmp);
-	  return FALSE;
-	}
-
-      tmp[i] = key;
-      i++;
-    }
-
-  *keys = tmp;
-
-  return TRUE;
-}
-
-static dbus_bool_t
-insert_entry (DBusDict *dict, 
-              const char *key,
-              DBusDictEntry **entry)
-{
-  char *tmp;
-
-  tmp = _dbus_strdup (key);
-
-  if (!tmp)
-    return FALSE;
-  
-  *entry = dbus_new0 (DBusDictEntry, 1);
-  
-  if (!*entry)
-    {
-      dbus_free (tmp);
-      return FALSE;
-    }
-
-  if (!_dbus_hash_table_insert_string (dict->table, tmp, *entry))
-    {
-      dbus_free (tmp);
-      dbus_dict_entry_free (*entry);
-
-      return FALSE;
-    }
-
-  return TRUE;
-}
-	      
-/**
- * Adds a boolean value to the dict. If a value with the same key
- * already exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_boolean (DBusDict    *dict,
-		       const char  *key,
-		       dbus_bool_t  value)
-{
-  DBusDictEntry *entry;
-
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_BOOLEAN;
-      entry->v.boolean_value = value;
-
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a 32 bit signed integer value to the dict. If a value with the
- * same key already exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_int32 (DBusDict     *dict,
-		     const char   *key,
-		     dbus_int32_t  value)
-{
-  DBusDictEntry *entry;
-
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_INT32;
-      entry->v.int32_value = value;
-
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a 32 bit unsigned integer value to the dict. If a value with
- * the same key already exists, then it will be replaced by the new
- * value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_uint32 (DBusDict      *dict,
-		      const char    *key,
-		      dbus_uint32_t  value)
-{
-  DBusDictEntry *entry;
-
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_UINT32;
-      entry->v.uint32_value = value;
-
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a 32 bit double value to the dict. If a value with the same
- * key already exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_double (DBusDict   *dict,
-		      const char *key,
-		      double      value)
-{
-  DBusDictEntry *entry;
-
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_DOUBLE;
-      entry->v.double_value = value;
-
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a string to the dict. If a value with the same key already
- * exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_string (DBusDict   *dict,
-		      const char *key,
-		      const char *value)
-{
-  DBusDictEntry *entry;
-  char *tmp;
-
-  tmp = _dbus_strdup (value);
-
-  if (!tmp)
-    return FALSE;
-  
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_STRING;
-      entry->v.string_value = tmp;
-
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a boolean array to the dict. If a value with the same key
- * already exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @param len the array length
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_boolean_array (DBusDict            *dict,
-			     const char          *key,
-			     unsigned const char *value,
-			     int                  len)
-{
-  DBusDictEntry *entry;
-  unsigned char *tmp;
-
-  if (len == 0)
-    tmp = NULL;
-  else
-    {
-      tmp = dbus_malloc (len);
-      
-      if (!tmp)
-	return FALSE;
-
-      memcpy (tmp, value, len);
-    }
-  
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_BOOLEAN_ARRAY;
-      entry->v.byte_array.value = tmp;
-      entry->v.byte_array.len = len;
-      
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a 32 bit signed integer array to the dict. If a value with the
- * same key already exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @param len the array length
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_int32_array (DBusDict           *dict,
-			   const char         *key,
-			   const dbus_int32_t *value,
-			   int                 len)
-{
-  DBusDictEntry *entry;
-  dbus_int32_t *tmp;
-
-  if (len == 0)
-    tmp = NULL;
-  else
-    {
-      tmp = dbus_new (dbus_int32_t, len);
-  
-      if (!tmp)
-	return FALSE;
-    }
-  
-  memcpy (tmp, value, len * sizeof (dbus_int32_t));
-  
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_INT32_ARRAY;
-      entry->v.int32_array.value = tmp;
-      entry->v.int32_array.len = len;
-      
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a 32 bit unsigned integer array to the dict. If a value with
- * the same key already exists, then it will be replaced by the new
- * value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @param len the array length
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_uint32_array (DBusDict             *dict,
-			    const char           *key,
-			    const dbus_uint32_t  *value,
-			    int                   len)
-{
-  DBusDictEntry *entry;
-  dbus_uint32_t *tmp;
-
-  if (len == 0)
-    tmp = NULL;
-  else
-    {
-      tmp = dbus_new (dbus_uint32_t, len);
-      
-      if (!tmp)
-	return FALSE;
-      
-      memcpy (tmp, value, len * sizeof (dbus_uint32_t));
-    }
-  
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_UINT32_ARRAY;
-      entry->v.uint32_array.value = tmp;
-      entry->v.int32_array.len = len;
-
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a double array to the dict. If a value with the same key
- * already exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @param len the array length
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_double_array (DBusDict     *dict,
-			    const char   *key,
-			    const double *value,
-			    int           len)
-{
-  DBusDictEntry *entry;
-  double *tmp;
-
-  if (len == 0)
-    tmp = NULL;
-  else
-    {
-      tmp = dbus_new (double, len);
-
-      if (!tmp)
-	return FALSE;
-
-      memcpy (tmp, value, len * sizeof (double));
-    }
-  
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_DOUBLE_ARRAY;
-      entry->v.double_array.value = tmp;
-      entry->v.double_array.len = len;
-
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Adds a byte array to the dict. If a value with the same key
- * already exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @param len the array length
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_byte_array (DBusDict             *dict,
-			  const char           *key,
-			  unsigned const char  *value,
-			  int                   len)
-{
-  DBusDictEntry *entry;
-  unsigned char *tmp;
-
-  if (len == 0)
-    tmp = NULL;
-  else
-    {
-      tmp = dbus_malloc (len);
-      
-      if (!tmp)
-	return FALSE;
-
-      memcpy (tmp, value, len);
-    }
-  
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_BYTE_ARRAY;
-      entry->v.byte_array.value = tmp;
-      entry->v.byte_array.len = len;
-      
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-
-/**
- * Adds a string array to the dict. If a value with the same key
- * already exists, then it will be replaced by the new value.
- *
- * @param dict the dict
- * @param key the key
- * @param value the value
- * @param len the array length
- * @returns #TRUE on success
- */
-dbus_bool_t
-dbus_dict_set_string_array (DBusDict    *dict,
-			    const char  *key,
-			    const char **value,
-			    int          len)
-{
-  DBusDictEntry *entry;
-  char **tmp;
-  int i;
-
-  tmp = dbus_new0 (char *, len + 1);
-  if (!tmp)
-    return FALSE;
-
-  tmp[len] = NULL;
-  
-  for (i = 0; i < len; i++)
-    {
-      tmp[i] = _dbus_strdup (value[i]);
-      if (!tmp[i])
-	{
-	  dbus_free_string_array (tmp);
-	  return FALSE;
-	}
-    }
-
-  if (insert_entry (dict, key, &entry))
-    {
-      entry->type = DBUS_TYPE_STRING_ARRAY;
-      entry->v.string_array.value = tmp;
-      entry->v.string_array.len = len;
-      
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-/**
- * Gets a boolean value from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_boolean (DBusDict    *dict,
-		       const char  *key,
-		       dbus_bool_t *value)
-{
-  DBusDictEntry *entry;
-
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-
-  if (!entry || entry->type != DBUS_TYPE_BOOLEAN)
-    return FALSE;
-
-  *value = entry->v.boolean_value;
-
-  return TRUE;
-}
-
-/**
- * Gets a 32 bit signed integer value from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_int32 (DBusDict     *dict,
-		     const char   *key,
-		     dbus_int32_t *value)
-{
-  DBusDictEntry *entry;
-
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-
-  if (!entry || entry->type != DBUS_TYPE_INT32)
-    return FALSE;
-
-  *value = entry->v.int32_value;
-
-  return TRUE;
-}
-
-/**
- * Gets a 32 bit unsigned integer value from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_uint32 (DBusDict      *dict,
-		      const char    *key,
-		      dbus_uint32_t *value)
-{
-  DBusDictEntry *entry;
-
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-
-  if (!entry || entry->type != DBUS_TYPE_UINT32)
-    return FALSE;
-
-  *value = entry->v.uint32_value;
-
-  return TRUE;
-}
-
-/**
- * Gets a double value from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_double (DBusDict   *dict,
-		      const char *key,
-		      double     *value)
-{
-  DBusDictEntry *entry;
-
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-
-  if (!entry || entry->type != DBUS_TYPE_DOUBLE)
-    return FALSE;
-
-  *value = entry->v.double_value;
-
-  return TRUE;
-}
-
-/**
- * Gets a string from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_string (DBusDict    *dict,
-		      const char  *key,
-		      const char **value)
-{
-  DBusDictEntry *entry;
-  
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-  
-  if (!entry || entry->type != DBUS_TYPE_STRING)
-    return FALSE;
-
-  *value = entry->v.string_value;
-
-  return TRUE;
-}
-
-/**
- * Gets a boolean array from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @param len return location for the array length
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_boolean_array (DBusDict             *dict,
-			     const char           *key,
-			     unsigned const char **value,
-			     int                  *len)
-{
-  DBusDictEntry *entry;
-  
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-  
-  if (!entry || entry->type != DBUS_TYPE_BOOLEAN_ARRAY)
-    return FALSE;
-
-  *value = entry->v.byte_array.value;
-  *len = entry->v.byte_array.len;
-  
-  return TRUE;
-}
-
-/**
- * Gets a 32 bit signed integer array from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @param len return location for the array length
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_int32_array (DBusDict            *dict,
-			   const char          *key,
-			   const dbus_int32_t **value,
-			   int                 *len)
-{
-  DBusDictEntry *entry;
-  
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-  
-  if (!entry || entry->type != DBUS_TYPE_INT32_ARRAY)
-    return FALSE;
-
-  *value = entry->v.int32_array.value;
-  *len = entry->v.int32_array.len;
-  
-  return TRUE;
-}
-
-/**
- * Gets a 32 bit unsigned integer array from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @param len return location for the array length
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_uint32_array (DBusDict             *dict,
-			    const char           *key,
-			    const dbus_uint32_t **value,
-			    int                  *len)
-{
-  DBusDictEntry *entry;
-  
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-  
-  if (!entry || entry->type != DBUS_TYPE_UINT32_ARRAY)
-    return FALSE;
-
-  *value = entry->v.uint32_array.value;
-  *len = entry->v.uint32_array.len;
-  
-  return TRUE;
-}
-
-/**
- * Gets a double array from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @param len return location for the array length
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_double_array (DBusDict      *dict,
-			    const char    *key,
-			    const double **value,
-			    int           *len)
-{
-  DBusDictEntry *entry;
-  
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-  
-  if (!entry || entry->type != DBUS_TYPE_DOUBLE_ARRAY)
-    return FALSE;
-
-  *value = entry->v.double_array.value;
-  *len = entry->v.double_array.len;
-  
-  return TRUE;
-}
-
-/**
- * Gets a byte array from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @param len return location for the array length
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_byte_array (DBusDict             *dict,
-			  const char           *key,
-			  unsigned const char **value,
-			  int                  *len)
-{
-  DBusDictEntry *entry;
-  
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-  
-  if (!entry || entry->type != DBUS_TYPE_BYTE_ARRAY)
-    return FALSE;
-
-  *value = entry->v.byte_array.value;
-  *len = entry->v.byte_array.len;
-  
-  return TRUE;
-}
-
-/**
- * Gets a string array from a dict using a key.
- *
- * @param dict the dict
- * @param key the key
- * @param value return location for the value
- * @param len return location for the array length
- * @returns #TRUE if the key exists and the value is of the correct
- * type
- */
-dbus_bool_t
-dbus_dict_get_string_array (DBusDict     *dict,
-			    const char   *key,
-			    const char ***value,
-			    int           *len)
-{
-  DBusDictEntry *entry;
-  
-  entry = _dbus_hash_table_lookup_string (dict->table, key);
-  
-  if (!entry || entry->type != DBUS_TYPE_STRING_ARRAY)
-    return FALSE;
-
-  *value = (const char **)entry->v.string_array.value;
-  *len = entry->v.string_array.len;
-  
-  return TRUE;
-}
-
-/** @} */
-
-#ifdef DBUS_BUILD_TESTS
-#include "dbus-test.h"
-
-dbus_bool_t
-_dbus_dict_test (void)
-{
-  DBusDict *dict;
-  dbus_bool_t our_bool;
-  dbus_int32_t our_int;
-  dbus_uint32_t our_uint;
-  double our_double;
-  const char *our_string;
-  const unsigned char boolean_array[] = { TRUE, FALSE, FALSE, TRUE };
-  const unsigned char *our_boolean_array;
-  const dbus_int32_t int32_array[] = { 0x12345678, -1911, 0, 0xaffe, 0xedd1e };
-  const dbus_int32_t *our_int32_array;
-  const dbus_uint32_t uint32_array[] = { 0x12345678, 0, 0xdeadbeef, 0x87654321, 0xffffffff };
-  const dbus_uint32_t *our_uint32_array;
-  const double double_array[] = { 3.14159, 1.2345, 6.7890 };
-  const double *our_double_array;
-  const char *string_array[] = { "This", "Is", "A", "Test" };
-  const char **our_string_array;
-  int i, len;
-
-  /* We don't test much here since the hash table tests cover a great
-     deal of the functionality. */
-
-  dict = dbus_dict_new ();
-
-  if (dbus_dict_get_value_type (dict, "foo") != DBUS_TYPE_NIL)
-    _dbus_assert_not_reached ("didn't return DBUS_TYPE_NIL for non-existant entry");
-
-  if (!dbus_dict_set_boolean (dict, "boolean", TRUE))
-    _dbus_assert_not_reached ("could not add boolean value");
-
-  if (!dbus_dict_get_boolean (dict, "boolean", &our_bool) ||
-      !our_bool)
-    _dbus_assert_not_reached ("could not get boolean value");
-
-  if (!dbus_dict_set_int32 (dict, "int32", 0x12345678))
-    _dbus_assert_not_reached ("could not add int32 value");
-
-  if (!dbus_dict_get_int32 (dict, "int32", &our_int) || our_int != 0x12345678)
-    _dbus_assert_not_reached ("could not get int32 value or int32 values differ");
-  
-  if (!dbus_dict_set_uint32 (dict, "uint32", 0x87654321))
-    _dbus_assert_not_reached ("could not add uint32 value");
-
-  if (!dbus_dict_get_uint32 (dict, "uint32", &our_uint) || our_uint != 0x87654321)
-    _dbus_assert_not_reached ("could not get uint32 value or uint32 values differ");
-
-  if (!dbus_dict_set_double (dict, "double", 3.14159))
-    _dbus_assert_not_reached ("could not add double value");
-
-  if (!dbus_dict_get_double (dict, "double", &our_double) || our_double != 3.14159)
-    _dbus_assert_not_reached ("could not get double value or double values differ");
-
-  if (!dbus_dict_set_string (dict, "string", "test string"))
-    _dbus_assert_not_reached ("could not add string value");
-
-  if (!dbus_dict_get_string (dict, "string", &our_string) || strcmp (our_string, "test string") != 0)
-    _dbus_assert_not_reached ("could not get string value or string values differ");
-
-  if (!dbus_dict_set_boolean_array (dict, "boolean_array", boolean_array, 4))
-    _dbus_assert_not_reached ("could not add boolean array");
-
-  if (!dbus_dict_get_boolean_array (dict, "boolean_array", &our_boolean_array, &len) ||
-      len != 4 || memcmp (boolean_array, our_boolean_array, 4) != 0)
-    _dbus_assert_not_reached ("could not get boolean array value or boolean array values differ");
-
-  if (!dbus_dict_set_int32_array (dict, "int32_array", int32_array, 5))
-    _dbus_assert_not_reached ("could not add int32 array");
-
-  if (!dbus_dict_get_int32_array (dict, "int32_array", &our_int32_array, &len) ||
-      len != 5 || memcmp (int32_array, our_int32_array, 5 * sizeof (dbus_int32_t)) != 0)
-    _dbus_assert_not_reached ("could not get int32 array value or int32 array values differ");
-
-  if (!dbus_dict_set_uint32_array (dict, "uint32_array", uint32_array, 5))
-    _dbus_assert_not_reached ("could not add uint32 array");
-
-  if (!dbus_dict_get_uint32_array (dict, "uint32_array", &our_uint32_array, &len) ||
-      len != 5 || memcmp (uint32_array, our_uint32_array, 5 * sizeof (dbus_uint32_t) ) != 0)
-    _dbus_assert_not_reached ("could not get uint32 array value or uint32 array values differ");
-
-  if (!dbus_dict_set_double_array (dict, "double_array", double_array, 3))
-    _dbus_assert_not_reached ("could not add double array");
-
-  if (!dbus_dict_get_double_array (dict, "double_array", &our_double_array, &len) ||
-      len != 3 || memcmp (double_array, our_double_array, 3 * sizeof (double)) != 0)
-    _dbus_assert_not_reached ("could not get double array value or double array values differ");
-
-  if (!dbus_dict_set_string_array (dict, "string_array", string_array, 4))
-    _dbus_assert_not_reached ("could not add string array");
-
-  if (!dbus_dict_get_string_array (dict, "string_array", &our_string_array, &len))
-    _dbus_assert_not_reached ("could not get string array value");
-
-  if (len != 4)
-    _dbus_assert_not_reached ("string array lengths differ");
-
-  for (i = 0; i < len; i++)
-    {
-      if (strcmp (our_string_array[i], string_array[i]) != 0)
-	_dbus_assert_not_reached ("string array fields differ");
-    }
-
-  dbus_dict_unref (dict);
-
-  return TRUE;
-}
-#endif /* DBUS_BUILD_TESTS */