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
|
/*
* Summary: Chained hash tables and domain/connections handling
* Description: This module implements the hash table and allocation and
* deallocation of domains and connections
*
* Copy: Copyright (C) 2005, 2011 Red Hat, Inc.
*
* Author: Bjorn Reese <bjorn.reese@systematic.dk>
* Daniel Veillard <veillard@redhat.com>
*/
#ifndef __VIR_HASH_H__
# define __VIR_HASH_H__
/*
* The hash table.
*/
typedef struct _virHashTable virHashTable;
typedef virHashTable *virHashTablePtr;
/*
* function types:
*/
/**
* virHashDataFree:
* @payload: the data in the hash
* @name: the name associated
*
* Callback to free data from a hash.
*/
typedef void (*virHashDataFree) (void *payload, const void *name);
/**
* virHashIterator:
* @payload: the data in the hash
* @name: the hash key
* @data: user supplied data blob
*
* Callback to process a hash entry during iteration
*/
typedef void (*virHashIterator) (void *payload, const void *name, void *data);
/**
* virHashSearcher:
* @payload: the data in the hash
* @name: the hash key
* @data: user supplied data blob
*
* Callback to identify hash entry desired
* Returns 1 if the hash entry is desired, 0 to move
* to next entry
*/
typedef int (*virHashSearcher) (const void *payload, const void *name,
const void *data);
/**
* virHashKeyCode:
* @name: the hash key
*
* Compute the hash code corresponding to the key @name
*
* Returns the hash code
*/
typedef uint32_t (*virHashKeyCode)(const void *name);
/**
* virHashKeyEqual:
* @namea: the first hash key
* @nameb: the second hash key
*
* Compare two hash keys for equality
*
* Returns true if the keys are equal, false otherwise
*/
typedef bool (*virHashKeyEqual)(const void *namea, const void *nameb);
/**
* virHashKeyCopy:
* @name: the hash key
*
* Create a copy of the hash key, duplicating
* memory allocation where applicable
*
* Returns a newly allocated copy of @name
*/
typedef void *(*virHashKeyCopy)(const void *name);
/**
* virHashKeyFree:
* @name: the hash key
*
* Free any memory associated with the hash
* key @name
*/
typedef void (*virHashKeyFree)(void *name);
/*
* Constructor and destructor.
*/
virHashTablePtr virHashCreate(ssize_t size,
virHashDataFree dataFree);
virHashTablePtr virHashCreateFull(ssize_t size,
virHashDataFree dataFree,
virHashKeyCode keyCode,
virHashKeyEqual keyEqual,
virHashKeyCopy keyCopy,
virHashKeyFree keyFree);
void virHashFree(virHashTablePtr table);
ssize_t virHashSize(virHashTablePtr table);
ssize_t virHashTableSize(virHashTablePtr table);
/*
* Add a new entry to the hash table.
*/
int virHashAddEntry(virHashTablePtr table,
const void *name, void *userdata);
int virHashUpdateEntry(virHashTablePtr table,
const void *name,
void *userdata);
/*
* Remove an entry from the hash table.
*/
int virHashRemoveEntry(virHashTablePtr table,
const void *name);
/*
* Retrieve the userdata.
*/
void *virHashLookup(virHashTablePtr table, const void *name);
/*
* Retrieve & remove the userdata.
*/
void *virHashSteal(virHashTablePtr table, const void *name);
/*
* Get the hash table's key/value pairs and have them optionally sorted.
* The returned array contains virHashSize() elements. Additionally,
* an empty element has been added to the end of the array (with key == NULL)
* to indicate the end of the array.
* The key/value pairs are only valid as long as the underlying hash
* table is not modified, i.e., no keys are removed or inserted, and
* the hash table is not deleted.
* The caller must only free the returned array using VIR_FREE().
* The caller must make copies of all returned keys and values if they are
* to be used somewhere else.
*/
typedef struct _virHashKeyValuePair virHashKeyValuePair;
typedef virHashKeyValuePair *virHashKeyValuePairPtr;
struct _virHashKeyValuePair {
const void *key;
const void *value;
};
typedef int (*virHashKeyComparator)(const virHashKeyValuePairPtr,
const virHashKeyValuePairPtr);
virHashKeyValuePairPtr virHashGetItems(virHashTablePtr table,
virHashKeyComparator compar);
/*
* Compare two tables for equality: the lookup of a key's value in
* both tables must result in an equivalent value.
* The caller must pass in a comparator function for comparing the values
* of two keys.
*/
typedef int (*virHashValueComparator)(const void *value1, const void *value2);
bool virHashEqual(const virHashTablePtr table1,
const virHashTablePtr table2,
virHashValueComparator compar);
/*
* Iterators
*/
ssize_t virHashForEach(virHashTablePtr table, virHashIterator iter, void *data);
ssize_t virHashRemoveSet(virHashTablePtr table, virHashSearcher iter, const void *data);
void *virHashSearch(virHashTablePtr table, virHashSearcher iter, const void *data);
#endif /* ! __VIR_HASH_H__ */
|
GitWeb