1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* dbus-hash.h Generic hash table utility (internal to D-Bus implementation)
*
* Copyright (C) 2002 Red Hat, Inc.
*
* SPDX-License-Identifier: AFL-2.1 OR GPL-2.0-or-later
*
* Licensed under the Academic Free License version 2.1
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifndef DBUS_HASH_H
#define DBUS_HASH_H
#include <stdint.h>
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#include <dbus/dbus-memory.h>
#include <dbus/dbus-types.h>
#include <dbus/dbus-sysdeps.h>
DBUS_BEGIN_DECLS
/**
* @addtogroup DBusHashTable
* @{
*/
/** Hash iterator object. The iterator is on the stack, but its real
* fields are hidden privately.
*/
struct DBusHashIter
{
void *dummy1; /**< Do not use. */
void *dummy2; /**< Do not use. */
void *dummy3; /**< Do not use. */
void *dummy4; /**< Do not use. */
int dummy5; /**< Do not use. */
int dummy6; /**< Do not use. */
};
typedef struct DBusHashTable DBusHashTable;
typedef struct DBusHashIter DBusHashIter;
/* Allowing an arbitrary function as with GLib
* would be nicer for a public API, but for
* an internal API this saves typing, we can add
* more whenever we feel like it.
*/
typedef enum
{
DBUS_HASH_STRING, /**< Hash keys are strings. */
DBUS_HASH_INT, /**< Hash keys are integers. */
DBUS_HASH_UINTPTR /**< Hash keys are integer capable to hold a pointer. */
} DBusHashType;
DBUS_PRIVATE_EXPORT
DBusHashTable* _dbus_hash_table_new (DBusHashType type,
DBusFreeFunction key_free_function,
DBusFreeFunction value_free_function);
DBUS_PRIVATE_EXPORT
DBusHashTable* _dbus_hash_table_ref (DBusHashTable *table);
DBUS_PRIVATE_EXPORT
void _dbus_hash_table_unref (DBusHashTable *table);
void _dbus_hash_table_remove_all (DBusHashTable *table);
DBUS_PRIVATE_EXPORT
void _dbus_hash_iter_init (DBusHashTable *table,
DBusHashIter *iter);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_iter_next (DBusHashIter *iter);
DBUS_PRIVATE_EXPORT
void _dbus_hash_iter_remove_entry (DBusHashIter *iter);
DBUS_PRIVATE_EXPORT
void* _dbus_hash_iter_get_value (DBusHashIter *iter);
DBUS_PRIVATE_EXPORT
void _dbus_hash_iter_set_value (DBusHashIter *iter,
void *value);
DBUS_PRIVATE_EXPORT
int _dbus_hash_iter_get_int_key (DBusHashIter *iter);
DBUS_PRIVATE_EXPORT
const char* _dbus_hash_iter_get_string_key (DBusHashIter *iter);
DBUS_PRIVATE_EXPORT
uintptr_t _dbus_hash_iter_get_uintptr_key (DBusHashIter *iter);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_iter_lookup (DBusHashTable *table,
void *key,
dbus_bool_t create_if_not_found,
DBusHashIter *iter);
DBUS_PRIVATE_EXPORT
void* _dbus_hash_table_lookup_string (DBusHashTable *table,
const char *key);
DBUS_PRIVATE_EXPORT
void* _dbus_hash_table_lookup_int (DBusHashTable *table,
int key);
DBUS_PRIVATE_EXPORT
void* _dbus_hash_table_lookup_uintptr (DBusHashTable *table,
uintptr_t key);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_remove_string (DBusHashTable *table,
const char *key);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_remove_int (DBusHashTable *table,
int key);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_remove_uintptr (DBusHashTable *table,
uintptr_t key);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_insert_string (DBusHashTable *table,
char *key,
void *value);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_insert_int (DBusHashTable *table,
int key,
void *value);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_insert_uintptr (DBusHashTable *table,
uintptr_t key,
void *value);
DBUS_PRIVATE_EXPORT
int _dbus_hash_table_get_n_entries (DBusHashTable *table);
DBUS_PRIVATE_EXPORT
char ** _dbus_hash_table_to_array (DBusHashTable *table,
char delimiter);
DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_from_array (DBusHashTable *table,
char **array,
char delimiter);
/* Preallocation */
/** A preallocated hash entry */
typedef struct DBusPreallocatedHash DBusPreallocatedHash;
DBUS_PRIVATE_EXPORT
DBusPreallocatedHash *_dbus_hash_table_preallocate_entry (DBusHashTable *table);
DBUS_PRIVATE_EXPORT
void _dbus_hash_table_free_preallocated_entry (DBusHashTable *table,
DBusPreallocatedHash *preallocated);
DBUS_PRIVATE_EXPORT
void _dbus_hash_table_insert_string_preallocated (DBusHashTable *table,
DBusPreallocatedHash *preallocated,
char *key,
void *value);
#ifdef DBUS_WIN
# define DBUS_HASH_POLLABLE DBUS_HASH_UINTPTR
#else
# define DBUS_HASH_POLLABLE DBUS_HASH_INT
#endif
static inline DBusPollable
_dbus_hash_iter_get_pollable_key (DBusHashIter *iter)
{
#ifdef DBUS_WIN
DBusSocket s;
s.sock = _dbus_hash_iter_get_uintptr_key (iter);
return s;
#else
return _dbus_hash_iter_get_int_key (iter);
#endif
}
static inline void *
_dbus_hash_table_lookup_pollable (DBusHashTable *table,
DBusPollable key)
{
#ifdef DBUS_WIN
return _dbus_hash_table_lookup_uintptr (table, key.sock);
#else
return _dbus_hash_table_lookup_int (table, key);
#endif
}
static inline dbus_bool_t
_dbus_hash_table_remove_pollable (DBusHashTable *table,
DBusPollable key)
{
#ifdef DBUS_WIN
return _dbus_hash_table_remove_uintptr (table, key.sock);
#else
return _dbus_hash_table_remove_int (table, key);
#endif
}
static inline dbus_bool_t
_dbus_hash_table_insert_pollable (DBusHashTable *table,
DBusPollable key,
void *value)
{
#ifdef DBUS_WIN
return _dbus_hash_table_insert_uintptr (table, key.sock, value);
#else
return _dbus_hash_table_insert_int (table, key, value);
#endif
}
static inline void
_dbus_clear_hash_table (DBusHashTable **table_p)
{
_dbus_clear_pointer_impl (DBusHashTable, table_p, _dbus_hash_table_unref);
}
/** @} */
DBUS_END_DECLS
#endif /* DBUS_HASH_H */
|
