Fwd: CPAN Upload: Y/YV/YVES/ExtUtils-Install-1.45.tar.gz
[perl.git] / NetWare / nwhashcls.cpp
1 /*
2  * Copyright � 2001 Novell, Inc. All Rights Reserved.
3  *
4  * You may distribute under the terms of either the GNU General Public
5  * License or the Artistic License, as specified in the README file.
6  *
7  */
8
9 /*
10  * FILENAME     :  hashcls.cpp
11  * DESCRIPTION  :  Implementation of Equivalent of Hash class, NWPerlHashList and 
12                                         NWPerlKeyHashList
13  *                 
14  * Author       :  Srivathsa M
15  * Date Created :  July 26 2001
16  */
17
18 #include "nwhashcls.h"
19
20 NWPerlHashList::NWPerlHashList()
21 {
22         //initialize the hash list to null
23         for(int i=0;i<BUCKET_SIZE;i++)
24                 MemListHash[i] = NULL;
25         DEBUGPRINT("In constructor\n");
26 }
27                         
28 NWPerlHashList::~NWPerlHashList()
29 {
30         DEBUGPRINT("In destructor\n");
31         removeAll();
32 }
33
34 int
35 NWPerlHashList::insert(void *ldata)
36 {
37         HASHNODE *list = new HASHNODE;
38         if (list) {
39                 list->data = ldata;
40                 list->next = NULL;
41                 unsigned long Bucket = ((unsigned long)ldata) % BUCKET_SIZE;
42                 if (MemListHash[Bucket]) {
43                         //Elements existing, insert at the beginning
44                         list->next = MemListHash[Bucket];
45                         MemListHash[Bucket] = list;
46                         DEBUGPRINT("Inserted to %d\n",Bucket);
47                 } else {
48                         //First element
49                         MemListHash[Bucket] = list;
50                         DEBUGPRINT("Inserted first time to %d\n",Bucket);
51                 }
52                 return 1;
53         } else 
54                 return 0;
55 }
56
57 int
58 NWPerlHashList::remove(void *ldata)
59 {
60         unsigned long Bucket = ((unsigned long)ldata) % BUCKET_SIZE;
61         HASHNODE *list = MemListHash[Bucket];
62         if (list) {
63                 int found = 0;
64                 HASHNODE *next =list;
65                 HASHNODE *prev =NULL;
66                 do 
67                 {
68                         if (list->data != ldata) {
69                                 prev = list;
70                                 list = list->next;
71                         }
72                         else {
73                                 found = 1;
74                                 next = list->next;
75                                 /*if(list->data)
76                                 {
77                                         free(list->data);
78                                         list->data = NULL;
79                                 }*/
80                                 //ConsolePrintf ("A:%x;",list->data);
81                                 delete list;
82                                 list = NULL;
83                                 if (prev) {
84                                         prev->next = next;
85                                 } else {
86                                         MemListHash[Bucket]=next;
87                                 }
88                                 DEBUGPRINT("Removed element from %d\n",Bucket);
89                         }
90                         ThreadSwitchWithDelay();
91                 } while(list && !found);
92 //              if (!found)
93 //                      ConsolePrintf("Couldn;t find %x in Bucket %d\n",ldata,Bucket);
94                 return(found);
95         } 
96         return 1;
97 }
98
99
100 void NWPerlHashList::forAll( register void (*user_fn)(void *, void*), void *data ) const 
101 {
102
103         for(int i=0; i<BUCKET_SIZE; i++) 
104         {
105                 HASHNODE *next = MemListHash[i];
106                 while(next)
107                 {
108                         HASHNODE *temp = next->next;
109                         if(next->data)
110                         {
111                                 DEBUGPRINT("- To remove element from bucket %d\n",i);
112                     user_fn( next->data, data );
113                         }
114                         next = temp;
115                         ThreadSwitchWithDelay();
116                 }
117         }
118         return ;
119 };
120
121 void NWPerlHashList::removeAll( ) const 
122 {
123
124         for(int i=0; i<BUCKET_SIZE; i++) 
125         {
126                 HASHNODE *next = MemListHash[i];
127                 while(next)
128                 {
129                         HASHNODE *temp = next->next;
130                         delete next;
131                         next = temp;
132                         ThreadSwitchWithDelay();
133                 }
134         }
135         return ;
136 };
137
138 /**
139 NWPerlKeyHashList::NWPerlKeyHashList()
140 {
141         //initialize the hash list to null
142         for(int i=0;i<BUCKET_SIZE;i++)
143                 MemListHash[i] = NULL;
144         DEBUGPRINT("In constructor\n");
145 }
146                         
147 NWPerlKeyHashList::~NWPerlKeyHashList()
148 {
149         DEBUGPRINT("In destructor\n");
150         removeAll();
151 }
152
153 int
154 NWPerlKeyHashList::insert(void *key, void *ldata)
155 {
156         KEYHASHNODE *list = new KEYHASHNODE;
157         if (list) {
158                 list->key = key;
159                 list->data = ldata;
160                 list->next = NULL;
161                 unsigned long Bucket = ((unsigned long)key) % BUCKET_SIZE;
162                 if (MemListHash[Bucket]) {
163                         //Elements existing, insert at the beginning
164                         list->next = MemListHash[Bucket];
165                         MemListHash[Bucket] = list;
166                         DEBUGPRINT("Inserted to %d\n",Bucket);
167                 } else {
168                         //First element
169                         MemListHash[Bucket] = list;
170                         DEBUGPRINT("Inserted first time to %d\n",Bucket);
171                 }
172                 return 1;
173         } else 
174                 return 0;
175 }
176
177 int
178 NWPerlKeyHashList::remove(void *key)
179 {
180         unsigned long Bucket = ((unsigned long)key) % BUCKET_SIZE;
181         KEYHASHNODE *list = MemListHash[Bucket];
182         if (list) {
183                 int found = 0;
184                 KEYHASHNODE *next =list;
185                 KEYHASHNODE *prev =NULL;
186                 do 
187                 {
188                         if (list->key != key) {
189                                 prev = list;
190                                 list = list->next;
191                         }
192                         else {
193                                 found = 1;
194                                 next = list->next;
195                                 delete list;
196                                 list = NULL;
197                                 if (prev) {
198                                         prev->next = next;
199                                 } else {
200                                         MemListHash[Bucket]=next;
201                                 }
202                                 DEBUGPRINT("Removed element from %d\n",Bucket);
203                         }
204                 } while(list && !found);
205 //              if (!found)
206 //                      ConsolePrintf("Couldn;t find %x in Bucket %d\n",key,Bucket);
207                 return(found);
208         } 
209         return 1;
210 }
211
212
213 void NWPerlKeyHashList::forAll( register void (*user_fn)(void *, void*), void *data ) const 
214 {
215
216         for(int i=0; i<BUCKET_SIZE; i++) 
217         {
218                 KEYHASHNODE *next = MemListHash[i];
219                 while(next)
220                 {
221                         KEYHASHNODE *temp = next->next;
222                         if(next->data)
223                         {
224                                 DEBUGPRINT("- To remove element from bucket %d\n",i);
225                     user_fn( next->data, data );
226                         }
227                         next = temp;
228                         ThreadSwitchWithDelay();
229                 }
230         }
231         return ;
232 };
233
234 int NWPerlKeyHashList::find(void *key,void **pData)
235 {
236         for(int i=0; i<BUCKET_SIZE; i++) 
237         {
238                 KEYHASHNODE *next = MemListHash[i];
239                 while(next)
240                 {
241                         if(next->key==key)
242                         {
243                                 *pData=next->data;
244                                 return 1;
245                         }
246                         next = next->next;
247                         ThreadSwitchWithDelay();
248                 }
249         }
250         return 0;
251 }
252
253 void NWPerlKeyHashList::removeAll( ) const 
254 {
255
256         for(int i=0; i<BUCKET_SIZE; i++) 
257         {
258                 KEYHASHNODE *next = MemListHash[i];
259                 while(next)
260                 {
261                         KEYHASHNODE *temp = next->next;
262                         delete next;
263                         next = temp;
264                         ThreadSwitchWithDelay();
265                 }
266         }
267         return ;
268 };
269 **/