File: ghash.h

package info (click to toggle)
glib2.0 2.58.3-2+deb10u2
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, buster-backports, buster-proposed-updates, sid
  • size: 48,956 kB
  • sloc: ansic: 452,656; xml: 16,781; python: 6,149; makefile: 3,776; sh: 1,499; perl: 1,140; cpp: 9
file content (190 lines) | stat: -rw-r--r-- 7,862 bytes parent folder | download
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
/* GLIB - Library of useful routines for C programming
 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */

/*
 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
 * file for a list of people on the GLib Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GLib at ftp://ftp.gtk.org/pub/gtk/.
 */

#ifndef __G_HASH_H__
#define __G_HASH_H__

#if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
#error "Only <glib.h> can be included directly."
#endif

#include <glib/gtypes.h>
#include <glib/glist.h>

G_BEGIN_DECLS

typedef struct _GHashTable  GHashTable;

typedef gboolean  (*GHRFunc)  (gpointer  key,
                               gpointer  value,
                               gpointer  user_data);

typedef struct _GHashTableIter GHashTableIter;

struct _GHashTableIter
{
  /*< private >*/
  gpointer      dummy1;
  gpointer      dummy2;
  gpointer      dummy3;
  int           dummy4;
  gboolean      dummy5;
  gpointer      dummy6;
};

GLIB_AVAILABLE_IN_ALL
GHashTable* g_hash_table_new               (GHashFunc       hash_func,
                                            GEqualFunc      key_equal_func);
GLIB_AVAILABLE_IN_ALL
GHashTable* g_hash_table_new_full          (GHashFunc       hash_func,
                                            GEqualFunc      key_equal_func,
                                            GDestroyNotify  key_destroy_func,
                                            GDestroyNotify  value_destroy_func);
GLIB_AVAILABLE_IN_ALL
void        g_hash_table_destroy           (GHashTable     *hash_table);
GLIB_AVAILABLE_IN_ALL
gboolean    g_hash_table_insert            (GHashTable     *hash_table,
                                            gpointer        key,
                                            gpointer        value);
GLIB_AVAILABLE_IN_ALL
gboolean    g_hash_table_replace           (GHashTable     *hash_table,
                                            gpointer        key,
                                            gpointer        value);
GLIB_AVAILABLE_IN_ALL
gboolean    g_hash_table_add               (GHashTable     *hash_table,
                                            gpointer        key);
GLIB_AVAILABLE_IN_ALL
gboolean    g_hash_table_remove            (GHashTable     *hash_table,
                                            gconstpointer   key);
GLIB_AVAILABLE_IN_ALL
void        g_hash_table_remove_all        (GHashTable     *hash_table);
GLIB_AVAILABLE_IN_ALL
gboolean    g_hash_table_steal             (GHashTable     *hash_table,
                                            gconstpointer   key);
GLIB_AVAILABLE_IN_2_58
gboolean    g_hash_table_steal_extended    (GHashTable     *hash_table,
                                            gconstpointer   lookup_key,
                                            gpointer       *stolen_key,
                                            gpointer       *stolen_value);
GLIB_AVAILABLE_IN_ALL
void        g_hash_table_steal_all         (GHashTable     *hash_table);
GLIB_AVAILABLE_IN_ALL
gpointer    g_hash_table_lookup            (GHashTable     *hash_table,
                                            gconstpointer   key);
GLIB_AVAILABLE_IN_ALL
gboolean    g_hash_table_contains          (GHashTable     *hash_table,
                                            gconstpointer   key);
GLIB_AVAILABLE_IN_ALL
gboolean    g_hash_table_lookup_extended   (GHashTable     *hash_table,
                                            gconstpointer   lookup_key,
                                            gpointer       *orig_key,
                                            gpointer       *value);
GLIB_AVAILABLE_IN_ALL
void        g_hash_table_foreach           (GHashTable     *hash_table,
                                            GHFunc          func,
                                            gpointer        user_data);
GLIB_AVAILABLE_IN_ALL
gpointer    g_hash_table_find              (GHashTable     *hash_table,
                                            GHRFunc         predicate,
                                            gpointer        user_data);
GLIB_AVAILABLE_IN_ALL
guint       g_hash_table_foreach_remove    (GHashTable     *hash_table,
                                            GHRFunc         func,
                                            gpointer        user_data);
GLIB_AVAILABLE_IN_ALL
guint       g_hash_table_foreach_steal     (GHashTable     *hash_table,
                                            GHRFunc         func,
                                            gpointer        user_data);
GLIB_AVAILABLE_IN_ALL
guint       g_hash_table_size              (GHashTable     *hash_table);
GLIB_AVAILABLE_IN_ALL
GList *     g_hash_table_get_keys          (GHashTable     *hash_table);
GLIB_AVAILABLE_IN_ALL
GList *     g_hash_table_get_values        (GHashTable     *hash_table);
GLIB_AVAILABLE_IN_2_40
gpointer *  g_hash_table_get_keys_as_array (GHashTable     *hash_table,
                                            guint          *length);

GLIB_AVAILABLE_IN_ALL
void        g_hash_table_iter_init         (GHashTableIter *iter,
                                            GHashTable     *hash_table);
GLIB_AVAILABLE_IN_ALL
gboolean    g_hash_table_iter_next         (GHashTableIter *iter,
                                            gpointer       *key,
                                            gpointer       *value);
GLIB_AVAILABLE_IN_ALL
GHashTable* g_hash_table_iter_get_hash_table (GHashTableIter *iter);
GLIB_AVAILABLE_IN_ALL
void        g_hash_table_iter_remove       (GHashTableIter *iter);
GLIB_AVAILABLE_IN_2_30
void        g_hash_table_iter_replace      (GHashTableIter *iter,
                                            gpointer        value);
GLIB_AVAILABLE_IN_ALL
void        g_hash_table_iter_steal        (GHashTableIter *iter);

GLIB_AVAILABLE_IN_ALL
GHashTable* g_hash_table_ref               (GHashTable     *hash_table);
GLIB_AVAILABLE_IN_ALL
void        g_hash_table_unref             (GHashTable     *hash_table);

#ifndef G_DISABLE_DEPRECATED
#define g_hash_table_freeze(hash_table) ((void)0)
#define g_hash_table_thaw(hash_table) ((void)0)
#endif

/* Hash Functions
 */
GLIB_AVAILABLE_IN_ALL
gboolean g_str_equal    (gconstpointer  v1,
                         gconstpointer  v2);
GLIB_AVAILABLE_IN_ALL
guint    g_str_hash     (gconstpointer  v);

GLIB_AVAILABLE_IN_ALL
gboolean g_int_equal    (gconstpointer  v1,
                         gconstpointer  v2);
GLIB_AVAILABLE_IN_ALL
guint    g_int_hash     (gconstpointer  v);

GLIB_AVAILABLE_IN_ALL
gboolean g_int64_equal  (gconstpointer  v1,
                         gconstpointer  v2);
GLIB_AVAILABLE_IN_ALL
guint    g_int64_hash   (gconstpointer  v);

GLIB_AVAILABLE_IN_ALL
gboolean g_double_equal (gconstpointer  v1,
                         gconstpointer  v2);
GLIB_AVAILABLE_IN_ALL
guint    g_double_hash  (gconstpointer  v);

GLIB_AVAILABLE_IN_ALL
guint    g_direct_hash  (gconstpointer  v) G_GNUC_CONST;
GLIB_AVAILABLE_IN_ALL
gboolean g_direct_equal (gconstpointer  v1,
                         gconstpointer  v2) G_GNUC_CONST;

G_END_DECLS

#endif /* __G_HASH_H__ */