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
|
/* list.h
*
* Simple struct with functions to create a list which associates ids with data
* -Allows for finding ids associated with data such as IPs or public keys in a short time
* -Should only be used if there are relatively few add/remove calls to the list
*
* Copyright (C) 2014 Tox project All Rights Reserved.
*
* This file is part of Tox.
*
* Tox 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 3 of the License, or
* (at your option) any later version.
*
* Tox 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 Tox. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "list.h"
/* Basically, the elements in the list are placed in order so that they can be searched for easily
* -each element is seen as a big-endian integer when ordering them
* -the ids array is maintained so that each id always matches
* -the search algorithm cuts down the time to find the id associated with a piece of data
* at the cost of slow add/remove functions for large lists
* -Starts at 1/2 of the array, compares the element in the array with the data,
* then moves +/- 1/4 of the array depending on whether the value is greater or lower,
* then +- 1/8, etc, until the value is matched or its position where it should be in the array is found
* -some considerations since the array size is never perfect
*/
#define INDEX(i) (~i)
/* Find data in list
*
* return value:
* >= 0 : id associated with data
* < 0 : no match, returns index (return value is INDEX(index)) where
* the data should be inserted
*/
static int find(LIST *list, void *data)
{
//should work well, but could be improved
if (list->n == 0) {
return INDEX(0);
}
uint32_t i = list->n / 2; //current position in the array
uint32_t delta = i / 2; //how much we move in the array
int d = -1; //used to determine if closest match is found
//closest match is found if we move back to where we have already been
while (1) {
int r = memcmp(data, list->data + list->size * i, list->size);
if (r == 0) {
return list->ids[i];
}
if (r > 0) {
//data is greater
//move down
i += delta;
if (d == 0 || i == list->n) {
//reached bottom of list, or closest match
return INDEX(i);
}
delta = (delta) / 2;
if (delta == 0) {
delta = 1;
d = 1;
}
} else {
//data is smaller
if (d == 1 || i == 0) {
//reached top or list or closest match
return INDEX(i);
}
//move up
i -= delta;
delta = (delta) / 2;
if (delta == 0) {
delta = 1;
d = 0;
}
}
}
}
void list_init(LIST *list, uint32_t element_size)
{
//set initial values
list->n = 0;
list->size = element_size;
list->data = NULL;
list->ids = NULL;
}
void list_free(LIST *list)
{
//free both arrays
free(list->data);
free(list->ids);
}
int list_find(LIST *list, void *data)
{
int r = find(list, data);
//return only -1 and positive values
if (r < 0) {
r = -1;
}
return r;
}
int list_add(LIST *list, void *data, int id)
{
//find where the new element should be inserted
//see: return value of find()
int i = find(list, data);
if (i >= 0) {
//already in list
return 0;
}
i = ~i;
//increase the size of the arrays by one
void *p;
p = realloc(list->data, list->size * (list->n + 1));
if (!p) {
return 0;
} else {
list->data = p;
}
p = realloc(list->ids, sizeof(int) * (list->n + 1));
if (!p) {
return 0;
} else {
list->ids = p;
}
//insert data to element array
memmove(list->data + (i + 1) * list->size, list->data + i * list->size, (list->n - i) * list->size);
memcpy(list->data + i * list->size, data, list->size);
//insert id to id array
memmove(&list->ids[i + 1], &list->ids[i], (list->n - i) * sizeof(int));
list->ids[i] = id;
//increase n
list->n++;
return 1;
}
int list_remove(LIST *list, void *data, int id)
{
int i = find(list, data);
if (i < 0) {
return 0;
}
if (list->ids[i] != id) {
//this should never happen
return 0;
}
list->n--;
memmove(list->data + i * list->size, list->data + (i + 1) * list->size, (list->n - i) * list->size);
memmove(&list->ids[i], &list->ids[i + 1], (list->n - i) * sizeof(int));
return 1;
}
|
