Updated init script.
[dtbartle/bnbt.git] / sort.cpp
1 /***\r
2 *\r
3 * BNBT Beta 8.0 - A C++ BitTorrent Tracker\r
4 * Copyright (C) 2003-2004 Trevor Hogan\r
5 *\r
6 * CBTT variations (C) 2003-2005 Harold Feit\r
7 *\r
8 * This library is free software; you can redistribute it and/or\r
9 * modify it under the terms of the GNU Lesser General Public\r
10 * License as published by the Free Software Foundation; either\r
11 * version 2.1 of the License, or (at your option) any later version.\r
12 *\r
13 * This library is distributed in the hope that it will be useful,\r
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
16 * Lesser General Public License for more details.\r
17 *\r
18 * You should have received a copy of the GNU Lesser General Public\r
19 * License along with this library; if not, write to the Free Software\r
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
21 *\r
22 ***/\r
23 \r
24 #include "bnbt.h"\r
25 #include "sort.h"\r
26 #include "tracker.h"\r
27 #include "util.h"\r
28 \r
29 int asortByName( const void *elem1, const void *elem2 )\r
30 {\r
31         return ( (struct torrent_t *)elem1 )->strLowerName.compare( ( (struct torrent_t *)elem2 )->strLowerName );\r
32 }\r
33 \r
34 int asortByComplete( const void *elem1, const void *elem2 )\r
35 {\r
36         return ( (struct torrent_t *)elem1 )->iComplete - ( (struct torrent_t *)elem2 )->iComplete;\r
37 }\r
38 \r
39 int asortByDL( const void *elem1, const void *elem2 )\r
40 {\r
41         return ( (struct torrent_t *)elem1 )->iDL - ( (struct torrent_t *)elem2 )->iDL;\r
42 }\r
43 \r
44 int asortByAdded( const void *elem1, const void *elem2 )\r
45 {\r
46         return ( (struct torrent_t *)elem1 )->strAdded.compare( ( (struct torrent_t *)elem2 )->strAdded );\r
47 }\r
48 \r
49 int asortBySize( const void *elem1, const void *elem2 )\r
50 {\r
51         // int64's will overflow, force a compare\r
52 \r
53         struct torrent_t *tor1 = (struct torrent_t *)elem1;\r
54         struct torrent_t *tor2 = (struct torrent_t *)elem2;\r
55 \r
56         if( tor1->iSize < tor2->iSize )\r
57                 return -1;\r
58         else if( tor1->iSize > tor2->iSize )\r
59                 return 1;\r
60         else\r
61                 return 0;\r
62 }\r
63 \r
64 int asortByFiles( const void *elem1, const void *elem2 )\r
65 {\r
66         return ( (struct torrent_t *)elem1 )->iFiles - ( (struct torrent_t *)elem2 )->iFiles;\r
67 }\r
68 \r
69 int asortByComments( const void *elem1, const void *elem2 )\r
70 {\r
71         return ( (struct torrent_t *)elem1 )->iComments - ( (struct torrent_t *)elem2 )->iComments;\r
72 }\r
73 \r
74 int asortByAvgLeft( const void *elem1, const void *elem2 )\r
75 {\r
76         // int64's will overflow, force a compare\r
77 \r
78         struct torrent_t *tor1 = (struct torrent_t *)elem1;\r
79         struct torrent_t *tor2 = (struct torrent_t *)elem2;\r
80 \r
81         if( tor1->iAverageLeft < tor2->iAverageLeft )\r
82                 return -1;\r
83         else if( tor1->iAverageLeft > tor2->iAverageLeft )\r
84                 return 1;\r
85         else\r
86                 return 0;\r
87 }\r
88 \r
89 int asortByAvgLeftPercent( const void *elem1, const void *elem2 )\r
90 {\r
91         return ( (struct torrent_t *)elem1 )->iAverageLeftPercent - ( (struct torrent_t *)elem2 )->iAverageLeftPercent;\r
92 }\r
93 \r
94 int asortByCompleted( const void *elem1, const void *elem2 )\r
95 {\r
96         return ( (struct torrent_t *)elem1 )->iCompleted - ( (struct torrent_t *)elem2 )->iCompleted;\r
97 }\r
98 \r
99 int asortByTransferred( const void *elem1, const void *elem2 )\r
100 {\r
101         // int64's will overflow, force a compare\r
102 \r
103         struct torrent_t *tor1 = (struct torrent_t *)elem1;\r
104         struct torrent_t *tor2 = (struct torrent_t *)elem2;\r
105 \r
106         if( tor1->iTransferred < tor2->iTransferred )\r
107                 return -1;\r
108         else if( tor1->iTransferred > tor2->iTransferred )\r
109                 return 1;\r
110         else\r
111                 return 0;\r
112 }\r
113 \r
114 int dsortByName( const void *elem1, const void *elem2 )\r
115 {\r
116         return ( (struct torrent_t *)elem2 )->strLowerName.compare( ( (struct torrent_t *)elem1 )->strLowerName );\r
117 }\r
118 \r
119 int dsortByComplete( const void *elem1, const void *elem2 )\r
120 {\r
121         return ( (struct torrent_t *)elem2 )->iComplete - ( (struct torrent_t *)elem1 )->iComplete;\r
122 }\r
123 \r
124 int dsortByDL( const void *elem1, const void *elem2 )\r
125 {\r
126         return ( (struct torrent_t *)elem2 )->iDL - ( (struct torrent_t *)elem1 )->iDL;\r
127 }\r
128 \r
129 int dsortByAdded( const void *elem1, const void *elem2 )\r
130 {\r
131         return ( (struct torrent_t *)elem2 )->strAdded.compare( ( (struct torrent_t *)elem1 )->strAdded );\r
132 }\r
133 \r
134 int dsortBySize( const void *elem1, const void *elem2 )\r
135 {\r
136         // int64's will overflow, force a compare\r
137 \r
138         struct torrent_t *tor1 = (struct torrent_t *)elem1;\r
139         struct torrent_t *tor2 = (struct torrent_t *)elem2;\r
140 \r
141         if( tor1->iSize < tor2->iSize )\r
142                 return 1;\r
143         else if( tor1->iSize > tor2->iSize )\r
144                 return -1;\r
145         else\r
146                 return 0;\r
147 }\r
148 \r
149 int dsortByFiles( const void *elem1, const void *elem2 )\r
150 {\r
151         return ( (struct torrent_t *)elem2 )->iFiles - ( (struct torrent_t *)elem1 )->iFiles;\r
152 }\r
153 \r
154 int dsortByComments( const void *elem1, const void *elem2 )\r
155 {\r
156         return ( (struct torrent_t *)elem2 )->iComments - ( (struct torrent_t *)elem1 )->iComments;\r
157 }\r
158 \r
159 int dsortByAvgLeft( const void *elem1, const void *elem2 )\r
160 {\r
161         // int64's will overflow, force a compare\r
162 \r
163         struct torrent_t *tor1 = (struct torrent_t *)elem1;\r
164         struct torrent_t *tor2 = (struct torrent_t *)elem2;\r
165 \r
166         if( tor1->iAverageLeft < tor2->iAverageLeft )\r
167                 return 1;\r
168         else if( tor1->iAverageLeft > tor2->iAverageLeft )\r
169                 return -1;\r
170         else\r
171                 return 0;\r
172 }\r
173 \r
174 int dsortByAvgLeftPercent( const void *elem1, const void *elem2 )\r
175 {\r
176         return ( (struct torrent_t *)elem2 )->iAverageLeftPercent - ( (struct torrent_t *)elem1 )->iAverageLeftPercent;\r
177 }\r
178 \r
179 int dsortByCompleted( const void *elem1, const void *elem2 )\r
180 {\r
181         return ( (struct torrent_t *)elem2 )->iCompleted - ( (struct torrent_t *)elem1 )->iCompleted;\r
182 }\r
183 \r
184 int dsortByTransferred( const void *elem1, const void *elem2 )\r
185 {\r
186         // int64's will overflow, force a compare\r
187 \r
188         struct torrent_t *tor1 = (struct torrent_t *)elem1;\r
189         struct torrent_t *tor2 = (struct torrent_t *)elem2;\r
190 \r
191         if( tor1->iTransferred < tor2->iTransferred )\r
192                 return 1;\r
193         else if( tor1->iTransferred > tor2->iTransferred )\r
194                 return -1;\r
195         else\r
196                 return 0;\r
197 }\r
198 \r
199 int asortpByUpped( const void *elem1, const void *elem2 )\r
200 {\r
201         // int64's will overflow, force a compare\r
202 \r
203         struct peer_t *peer1 = (struct peer_t *)elem1;\r
204         struct peer_t *peer2 = (struct peer_t *)elem2;\r
205 \r
206         if( peer1->iUpped < peer2->iUpped )\r
207                 return -1;\r
208         else if( peer1->iUpped > peer2->iUpped )\r
209                 return 1;\r
210         else\r
211                 return 0;\r
212 }\r
213 \r
214 int asortpByDowned( const void *elem1, const void *elem2 )\r
215 {\r
216         // int64's will overflow, force a compare\r
217 \r
218         struct peer_t *peer1 = (struct peer_t *)elem1;\r
219         struct peer_t *peer2 = (struct peer_t *)elem2;\r
220 \r
221         if( peer1->iDowned < peer2->iDowned )\r
222                 return -1;\r
223         else if( peer1->iDowned > peer2->iDowned )\r
224                 return 1;\r
225         else\r
226                 return 0;\r
227 }\r
228 \r
229 int asortpByLeft( const void *elem1, const void *elem2 )\r
230 {\r
231         // int64's will overflow, force a compare\r
232 \r
233         struct peer_t *peer1 = (struct peer_t *)elem1;\r
234         struct peer_t *peer2 = (struct peer_t *)elem2;\r
235 \r
236         if( peer1->iLeft < peer2->iLeft )\r
237                 return -1;\r
238         else if( peer1->iLeft > peer2->iLeft )\r
239                 return 1;\r
240         else\r
241                 return 0;\r
242 }\r
243 \r
244 int asortpByConnected( const void *elem1, const void *elem2 )\r
245 {\r
246         return ( (struct peer_t *)elem1 )->iConnected - ( (struct peer_t *)elem2 )->iConnected;\r
247 }\r
248 \r
249 int asortpByShareRatio( const void *elem1, const void *elem2 )\r
250 {\r
251         float fl1 = ( (struct peer_t *)elem1 )->flShareRatio;\r
252         float fl2 = ( (struct peer_t *)elem2 )->flShareRatio;\r
253 \r
254         // this is complicated because -1 means infinite and casting to ints won't work\r
255 \r
256         if( fl1 == fl2 )\r
257                 return 0;\r
258         else if( fl1 == -1.0 )\r
259                 return 1;\r
260         else if( fl2 == -1.0 )\r
261                 return -1;\r
262         else if( fl1 < fl2 )\r
263                 return -1;\r
264         else\r
265                 return 1;\r
266 }\r
267 \r
268 int dsortpByUpped( const void *elem1, const void *elem2 )\r
269 {\r
270         // int64's will overflow, force a compare\r
271 \r
272         struct peer_t *peer1 = (struct peer_t *)elem1;\r
273         struct peer_t *peer2 = (struct peer_t *)elem2;\r
274 \r
275         if( peer1->iUpped < peer2->iUpped )\r
276                 return 1;\r
277         else if( peer1->iUpped > peer2->iUpped )\r
278                 return -1;\r
279         else\r
280                 return 0;\r
281 }\r
282 \r
283 int dsortpByDowned( const void *elem1, const void *elem2 )\r
284 {\r
285         // int64's will overflow, force a compare\r
286 \r
287         struct peer_t *peer1 = (struct peer_t *)elem1;\r
288         struct peer_t *peer2 = (struct peer_t *)elem2;\r
289 \r
290         if( peer1->iDowned < peer2->iDowned )\r
291                 return 1;\r
292         else if( peer1->iDowned > peer2->iDowned )\r
293                 return -1;\r
294         else\r
295                 return 0;\r
296 }\r
297 \r
298 int dsortpByLeft( const void *elem1, const void *elem2 )\r
299 {\r
300         // int64's will overflow, force a compare\r
301 \r
302         struct peer_t *peer1 = (struct peer_t *)elem1;\r
303         struct peer_t *peer2 = (struct peer_t *)elem2;\r
304 \r
305         if( peer1->iLeft < peer2->iLeft )\r
306                 return 1;\r
307         else if( peer1->iLeft > peer2->iLeft )\r
308                 return -1;\r
309         else\r
310                 return 0;\r
311 }\r
312 \r
313 int dsortpByConnected( const void *elem1, const void *elem2 )\r
314 {\r
315         return ( (struct peer_t *)elem2 )->iConnected - ( (struct peer_t *)elem1 )->iConnected;\r
316 }\r
317 \r
318 int dsortpByShareRatio( const void *elem1, const void *elem2 )\r
319 {\r
320         float fl1 = ( (struct peer_t *)elem1 )->flShareRatio;\r
321         float fl2 = ( (struct peer_t *)elem2 )->flShareRatio;\r
322 \r
323         // this is complicated because -1 means infinite and casting to ints won't work\r
324 \r
325         if( fl1 == fl2 )\r
326                 return 0;\r
327         else if( fl1 == -1.0 )\r
328                 return -1;\r
329         else if( fl2 == -1.0 )\r
330                 return 1;\r
331         else if( fl1 < fl2 )\r
332                 return 1;\r
333         else\r
334                 return -1;\r
335 }\r
336 \r
337 int asortuByLogin( const void *elem1, const void *elem2 )\r
338 {\r
339         return ( (struct user_t *)elem1 )->strLowerLogin.compare( ( (struct user_t *)elem2 )->strLowerLogin );\r
340 }\r
341 \r
342 int asortuByAccess( const void *elem1, const void *elem2 )\r
343 {\r
344         return ( (struct user_t *)elem2 )->iAccess - ( (struct user_t *)elem1 )->iAccess;\r
345 }\r
346 \r
347 int asortuByMail( const void *elem1, const void *elem2 )\r
348 {\r
349         return ( (struct user_t *)elem1 )->strLowerMail.compare( ( (struct user_t *)elem2 )->strLowerMail );\r
350 }\r
351 \r
352 int asortuByCreated( const void *elem1, const void *elem2 )\r
353 {\r
354         return ( (struct user_t *)elem1 )->strCreated.compare( ( (struct user_t *)elem2 )->strCreated );\r
355 }\r
356 \r
357 int dsortuByLogin( const void *elem1, const void *elem2 )\r
358 {\r
359         return ( (struct user_t *)elem2 )->strLowerLogin.compare( ( (struct user_t *)elem1 )->strLowerLogin );\r
360 }\r
361 \r
362 int dsortuByAccess( const void *elem1, const void *elem2 )\r
363 {\r
364         return ( (struct user_t *)elem1 )->iAccess - ( (struct user_t *)elem2 )->iAccess;\r
365 }\r
366 \r
367 int dsortuByMail( const void *elem1, const void *elem2 )\r
368 {\r
369         return ( (struct user_t *)elem2 )->strLowerMail.compare( ( (struct user_t *)elem1 )->strLowerMail );\r
370 }\r
371 \r
372 int dsortuByCreated( const void *elem1, const void *elem2 )\r
373 {\r
374         return ( (struct user_t *)elem2 )->strCreated.compare( ( (struct user_t *)elem1 )->strCreated );\r
375 }\r