← Back to branch summary

~n-muench/ubuntu/precise/open-vm-tools/open-vm-tools-precise.sid-merge1

« back to all changes in this revision

Viewing changes to lib/include/hashTable.h

  • Committer: Evan Broder
  • Date: 2010-03-21 23:26:53 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: broder@mit.edu-20100321232653-5a57r7v7ch4o6byv
Merging shared upstream rev into target branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/include/hashTable.h
53
53
#define HASH_FLAG_COPYKEY       0x10    // copy string key
54
54
 
55
55
HashTable *
56
 
HashTable_Alloc(uint32 numEntries, int keyType, HashTableFreeEntryFn fn);
 
56
HashTable_Alloc(uint32               numEntries,
 
57
                int                  keyType,
 
58
                HashTableFreeEntryFn fn);
57
59
 
58
60
HashTable *
59
 
HashTable_AllocOnce(Atomic_Ptr *var, uint32 numEntries, int keyType,
 
61
HashTable_AllocOnce(Atomic_Ptr          *var,
 
62
                    uint32               numEntries,
 
63
                    int                  keyType,
60
64
                    HashTableFreeEntryFn fn);
61
65
 
62
66
void
64
68
 
65
69
Bool
66
70
HashTable_Insert(HashTable  *hashTable,
67
 
                 const char *keyStr,
 
71
                 const void *keyStr,
68
72
                 void       *clientData);
69
73
 
70
74
Bool
71
75
HashTable_Lookup(HashTable  *hashTable,
72
 
                 const char *keyStr,
73
 
                 void **clientData);
 
76
                 const void *keyStr,
 
77
                 void      **clientData);
74
78
 
75
79
void *
76
80
HashTable_LookupOrInsert(HashTable  *hashTable,
77
 
                         const char *keyStr,
 
81
                         const void *keyStr,
78
82
                         void       *clientData);
79
83
 
80
84
Bool
81
85
HashTable_ReplaceOrInsert(HashTable  *hashTable,
82
 
                          const char *keyStr,
 
86
                          const void *keyStr,
83
87
                          void       *clientData);
84
88
 
85
89
Bool
86
90
HashTable_ReplaceIfEqual(HashTable  *hashTable,
87
 
                         const char *keyStr,
 
91
                         const void *keyStr,
88
92
                         void       *oldClientData,
89
93
                         void       *newClientData);
90
94
 
91
95
Bool
92
96
HashTable_Delete(HashTable  *hashTable,
93
 
                 const char *keyStr);
 
97
                 const void *keyStr);
94
98
 
95
99
Bool
96
100
HashTable_LookupAndDelete(HashTable  *hashTable,
97
 
                          const char *keyStr,
98
 
                          void **clientData);
 
101
                          const void *keyStr,
 
102
                          void      **clientData);
99
103
 
100
104
void
101
105
HashTable_Clear(HashTable *ht);
102
106
 
103
107
void
104
 
HashTable_ToArray(const HashTable *ht,
105
 
                  void ***clientDatas,
106
 
                  size_t *size);
 
108
HashTable_ToArray(const HashTable   *ht,
 
109
                  void            ***clientDatas,
 
110
                  size_t            *size);
107
111
 
108
112
size_t
109
113
HashTable_GetNumElements(const HashTable *ht);
110
114
 
111
115
int
112
 
HashTable_ForEach(const HashTable *ht,
113
 
                  HashTableForEachCallback cb,
114
 
                  void *clientData);
 
116
HashTable_ForEach(const HashTable          *ht,
 
117
                  HashTableForEachCallback  cb,
 
118
                  void                     *clientData);
115
119
 
116
120
#endif