Merge branch 'dbus-1.2'
[platform/upstream/dbus.git] / dbus / dbus-hash.h
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-hash.h Generic hash table utility (internal to D-Bus implementation)
3  * 
4  * Copyright (C) 2002  Red Hat, Inc.
5  *
6  * Licensed under the Academic Free License version 2.1
7  * 
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  * 
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  *
22  */
23
24 #ifndef DBUS_HASH_H
25 #define DBUS_HASH_H
26
27 #ifdef HAVE_STDINT_H
28 #include <stdint.h>
29 #endif
30
31 #ifdef HAVE_INTTYPES_H
32 #include <inttypes.h>
33 #endif
34
35 #include <dbus/dbus-memory.h>
36 #include <dbus/dbus-types.h>
37 #include <dbus/dbus-sysdeps.h>
38
39 DBUS_BEGIN_DECLS
40
41 /**
42  * @addtogroup DBusHashTable
43  * @{
44  */
45
46 /** Hash iterator object. The iterator is on the stack, but its real
47  * fields are hidden privately.
48  */
49 struct DBusHashIter
50 {
51   void *dummy1; /**< Do not use. */
52   void *dummy2; /**< Do not use. */
53   void *dummy3; /**< Do not use. */
54   void *dummy4; /**< Do not use. */
55   int   dummy5; /**< Do not use. */
56   int   dummy6; /**< Do not use. */
57 };
58
59 typedef struct DBusHashTable DBusHashTable;
60 typedef struct DBusHashIter  DBusHashIter;
61
62 /* Allowing an arbitrary function as with GLib
63  * would be nicer for a public API, but for
64  * an internal API this saves typing, we can add
65  * more whenever we feel like it.
66  */
67 typedef enum
68 {
69   DBUS_HASH_STRING,        /**< Hash keys are strings. */
70   DBUS_HASH_TWO_STRINGS,   /**< Hash key is two strings in one memory block, i.e. foo\\0bar\\0 */
71   DBUS_HASH_INT,           /**< Hash keys are integers. */
72   DBUS_HASH_POINTER,       /**< Hash keys are pointers. */
73   DBUS_HASH_UINTPTR        /**< Hash keys are integer capable to hold a pointer. */
74 } DBusHashType;
75
76 DBusHashTable* _dbus_hash_table_new                (DBusHashType      type,
77                                                     DBusFreeFunction  key_free_function,
78                                                     DBusFreeFunction  value_free_function);
79 DBusHashTable* _dbus_hash_table_ref                (DBusHashTable    *table);
80 void           _dbus_hash_table_unref              (DBusHashTable    *table);
81 void           _dbus_hash_table_remove_all         (DBusHashTable    *table);
82 void           _dbus_hash_iter_init                (DBusHashTable    *table,
83                                                     DBusHashIter     *iter);
84 dbus_bool_t    _dbus_hash_iter_next                (DBusHashIter     *iter);
85 void           _dbus_hash_iter_remove_entry        (DBusHashIter     *iter);
86 void*          _dbus_hash_iter_get_value           (DBusHashIter     *iter);
87 void           _dbus_hash_iter_set_value           (DBusHashIter     *iter,
88                                                     void             *value);
89 int            _dbus_hash_iter_get_int_key         (DBusHashIter     *iter);
90 const char*    _dbus_hash_iter_get_string_key      (DBusHashIter     *iter);
91 const char*    _dbus_hash_iter_get_two_strings_key (DBusHashIter     *iter);
92 uintptr_t      _dbus_hash_iter_get_uintptr_key     (DBusHashIter     *iter);
93 dbus_bool_t    _dbus_hash_iter_lookup              (DBusHashTable    *table,
94                                                     void             *key,
95                                                     dbus_bool_t       create_if_not_found,
96                                                     DBusHashIter     *iter);
97 void*          _dbus_hash_table_lookup_string      (DBusHashTable    *table,
98                                                     const char       *key);
99 void*          _dbus_hash_table_lookup_two_strings (DBusHashTable    *table,
100                                                     const char       *key);
101 void*          _dbus_hash_table_lookup_int         (DBusHashTable    *table,
102                                                     int               key);
103 void*          _dbus_hash_table_lookup_pointer     (DBusHashTable    *table,
104                                                     void             *key);
105 void*          _dbus_hash_table_lookup_uintptr     (DBusHashTable    *table,
106                                                     uintptr_t         key);
107 dbus_bool_t    _dbus_hash_table_remove_string      (DBusHashTable    *table,
108                                                     const char       *key);
109 dbus_bool_t    _dbus_hash_table_remove_two_strings (DBusHashTable    *table,
110                                                     const char       *key);
111 dbus_bool_t    _dbus_hash_table_remove_int         (DBusHashTable    *table,
112                                                     int               key);
113 dbus_bool_t    _dbus_hash_table_remove_pointer     (DBusHashTable    *table,
114                                                     void             *key);
115 dbus_bool_t    _dbus_hash_table_remove_uintptr     (DBusHashTable    *table,
116                                                     uintptr_t         key);
117 dbus_bool_t    _dbus_hash_table_insert_string      (DBusHashTable    *table,
118                                                     char             *key,
119                                                     void             *value);
120 dbus_bool_t    _dbus_hash_table_insert_two_strings (DBusHashTable    *table,
121                                                     char             *key,
122                                                     void             *value);
123 dbus_bool_t    _dbus_hash_table_insert_int         (DBusHashTable    *table,
124                                                     int               key,
125                                                     void             *value);
126 dbus_bool_t    _dbus_hash_table_insert_pointer     (DBusHashTable    *table,
127                                                     void             *key,
128                                                     void             *value);
129 dbus_bool_t    _dbus_hash_table_insert_uintptr     (DBusHashTable    *table,
130                                                     uintptr_t         key,
131                                                     void             *value);
132 int            _dbus_hash_table_get_n_entries      (DBusHashTable    *table);
133
134 /* Preallocation */
135
136 /** A preallocated hash entry */
137 typedef struct DBusPreallocatedHash DBusPreallocatedHash;
138
139 DBusPreallocatedHash *_dbus_hash_table_preallocate_entry          (DBusHashTable        *table);
140 void                  _dbus_hash_table_free_preallocated_entry    (DBusHashTable        *table,
141                                                                    DBusPreallocatedHash *preallocated);
142 void                  _dbus_hash_table_insert_string_preallocated (DBusHashTable        *table,
143                                                                    DBusPreallocatedHash *preallocated,
144                                                                    char                 *key,
145                                                                    void                 *value);
146
147 /** @} */
148
149 DBUS_END_DECLS
150
151 #endif /* DBUS_HASH_H */