Updated init script.
[dtbartle/bnbt.git] / atom.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 "atom.h"\r
26 #include "util.h"\r
27 \r
28 //\r
29 // CAtomInt\r
30 //\r
31 \r
32 CAtomInt :: CAtomInt( )\r
33 {\r
34         setValue( 0 );\r
35 }\r
36 \r
37 CAtomInt :: CAtomInt( int iInt )\r
38 {\r
39         setValue( iInt );\r
40 }\r
41 \r
42 CAtomInt :: CAtomInt( const CAtomInt &c )\r
43 {\r
44         // copy constructor\r
45 \r
46         setValue( c.getValue( ) );\r
47 }\r
48 \r
49 CAtomInt :: ~CAtomInt( )\r
50 {\r
51 \r
52 }\r
53 \r
54 int CAtomInt :: EncodedLength( )\r
55 {\r
56         return toString( ).size( ) + 2;\r
57 }\r
58 \r
59 int CAtomInt :: Length( )\r
60 {\r
61         return toString( ).size( );\r
62 }\r
63 \r
64 string CAtomInt :: toString( )\r
65 {\r
66         char pBuf[32];\r
67         memset( pBuf, 0, sizeof( char ) * 32 );\r
68         sprintf( pBuf, "%d", getValue( ) );\r
69         return pBuf;\r
70 }\r
71 \r
72 int CAtomInt :: getValue( ) const\r
73 {\r
74         return m_iInt;\r
75 }\r
76 \r
77 void CAtomInt :: setValue( int iInt )\r
78 {\r
79         m_iInt = iInt;\r
80 }\r
81 \r
82 //\r
83 // CAtomLong\r
84 //\r
85 \r
86 CAtomLong :: CAtomLong( )\r
87 {\r
88         setValue( 0 );\r
89 }\r
90 \r
91 CAtomLong :: CAtomLong( int64 iLong )\r
92 {\r
93         setValue( iLong );\r
94 }\r
95 \r
96 CAtomLong :: CAtomLong( const CAtomLong &c )\r
97 {\r
98         // copy constructor\r
99 \r
100         setValue( c.getValue( ) );\r
101 }\r
102 \r
103 CAtomLong :: ~CAtomLong( )\r
104 {\r
105 \r
106 }\r
107 \r
108 int CAtomLong :: EncodedLength( )\r
109 {\r
110         return toString( ).size( ) + 2;\r
111 }\r
112 \r
113 int CAtomLong :: Length( )\r
114 {\r
115         return toString( ).size( );\r
116 }\r
117 \r
118 string CAtomLong :: toString( )\r
119 {\r
120         char pBuf[32];\r
121         memset( pBuf, 0, sizeof( char ) * 32 );\r
122 \r
123 #if defined( WIN32 )\r
124         sprintf( pBuf, "%I64d", getValue( ) );\r
125 #elif defined( __FREEBSD__ )\r
126         sprintf( pBuf, "%qd", getValue( ) );\r
127 #else\r
128         sprintf( pBuf, "%lld", getValue( ) );\r
129 #endif\r
130 \r
131         return pBuf;\r
132 }\r
133 \r
134 int64 CAtomLong :: getValue( ) const\r
135 {\r
136         return m_iLong;\r
137 }\r
138 \r
139 void CAtomLong :: setValue( int64 iLong )\r
140 {\r
141         m_iLong = iLong;\r
142 }\r
143 \r
144 //\r
145 // CAtomString\r
146 //\r
147 \r
148 CAtomString :: CAtomString( )\r
149 {\r
150 \r
151 }\r
152 \r
153 CAtomString :: CAtomString( string strString )\r
154 {\r
155         setValue( strString );\r
156 }\r
157 \r
158 CAtomString :: CAtomString( const CAtomString &c )\r
159 {\r
160         // copy constructor\r
161 \r
162         setValue( c.getValue( ) );\r
163 }\r
164 \r
165 CAtomString :: ~CAtomString( )\r
166 {\r
167 \r
168 }\r
169 \r
170 int CAtomString :: EncodedLength( )\r
171 {\r
172         int iSize = getValue( ).size( );\r
173         char pBuf[32];\r
174         memset( pBuf, 0, sizeof( char ) * 32 );\r
175         sprintf( pBuf, "%d", iSize );\r
176         return iSize + strlen( pBuf ) + 1;\r
177 }\r
178 \r
179 int CAtomString :: Length( )\r
180 {\r
181         return getValue( ).size( );\r
182 }\r
183 \r
184 string CAtomString :: toString( )\r
185 {\r
186         return getValue( );\r
187 }\r
188 \r
189 string CAtomString :: getValue( ) const\r
190 {\r
191         return m_strString;\r
192 }\r
193 \r
194 void CAtomString :: setValue( string strString )\r
195 {\r
196         m_strString = strString;\r
197 }\r
198 \r
199 //\r
200 // CAtomList\r
201 //\r
202 \r
203 CAtomList :: CAtomList( )\r
204 {\r
205 \r
206 }\r
207 \r
208 CAtomList :: CAtomList( vector<CAtom *> vecList )\r
209 {\r
210         setValue( vecList );\r
211 }\r
212 \r
213 CAtomList :: CAtomList( const CAtomList &c )\r
214 {\r
215         // copy constructor\r
216 \r
217         vector<CAtom *> *pvecList = c.getValuePtr( );\r
218 \r
219         for( vector<CAtom *> :: iterator i = pvecList->begin( ); i != pvecList->end( ); i++ )\r
220         {\r
221                 if( dynamic_cast<CAtomInt *>( *i ) )\r
222                         addItem( new CAtomInt( *dynamic_cast<CAtomInt *>( *i ) ) );\r
223                 else if( dynamic_cast<CAtomLong *>( *i ) )\r
224                         addItem( new CAtomLong( *dynamic_cast<CAtomLong *>( *i ) ) );\r
225                 else if( dynamic_cast<CAtomString *>( *i ) )\r
226                         addItem( new CAtomString( *dynamic_cast<CAtomString *>( *i ) ) );\r
227                 else if( dynamic_cast<CAtomList *>( *i ) )\r
228                         addItem( new CAtomList( *dynamic_cast<CAtomList *>( *i ) ) );\r
229                 else if( dynamic_cast<CAtomDicti *>( *i ) )\r
230                         addItem( new CAtomDicti( *dynamic_cast<CAtomDicti *>( *i ) ) );\r
231                 else\r
232                         UTIL_LogPrint( "error copying list - found invalid atom, ignoring\n" );\r
233         }\r
234 }\r
235 \r
236 CAtomList :: ~CAtomList( )\r
237 {\r
238         clear( );\r
239 }\r
240 \r
241 int CAtomList :: EncodedLength( )\r
242 {\r
243         int iLen = 0;\r
244 \r
245         for( vector<CAtom *> :: iterator i = m_vecList.begin( ); i != m_vecList.end( ); i++ )\r
246                 iLen += (*i)->EncodedLength( );\r
247 \r
248         return iLen + 2;\r
249 }\r
250 \r
251 int CAtomList :: Length( )\r
252 {\r
253         // nobody cares about you\r
254 \r
255         return 0;\r
256 }\r
257 \r
258 string CAtomList :: toString( )\r
259 {\r
260         return string( );\r
261 }\r
262 \r
263 bool CAtomList :: isEmpty( )\r
264 {\r
265         return m_vecList.empty( );\r
266 }\r
267 \r
268 void CAtomList :: clear( )\r
269 {\r
270         for( vector<CAtom *> :: iterator i = m_vecList.begin( ); i != m_vecList.end( ); i++ )\r
271                 delete *i;\r
272 \r
273         m_vecList.clear( );\r
274 }\r
275 \r
276 void CAtomList :: Randomize( )\r
277 {\r
278         random_shuffle( m_vecList.begin( ), m_vecList.end( ) );\r
279 }\r
280 \r
281 vector<CAtom *> CAtomList :: getValue( ) const\r
282 {\r
283         return m_vecList;\r
284 }\r
285 \r
286 vector<CAtom *> *CAtomList :: getValuePtr( ) const\r
287 {\r
288         return (vector<CAtom *> *)&m_vecList;\r
289 }\r
290 \r
291 void CAtomList :: setValue( vector<CAtom *> vecList )\r
292 {\r
293         m_vecList = vecList;\r
294 }\r
295 \r
296 void CAtomList :: delItem( CAtom *atmItem )\r
297 {\r
298         for( vector<CAtom *> :: iterator i = m_vecList.begin( ); i != m_vecList.end( ); i++ )\r
299         {\r
300                 if( *i == atmItem )\r
301                 {\r
302                         delete *i;\r
303 \r
304                         m_vecList.erase( i );\r
305 \r
306                         return;\r
307                 }\r
308         }\r
309 }\r
310 \r
311 void CAtomList :: addItem( CAtom *atmItem )\r
312 {\r
313         m_vecList.push_back( atmItem );\r
314 }\r
315 \r
316 //\r
317 // CAtomDicti\r
318 //\r
319 \r
320 CAtomDicti :: CAtomDicti( )\r
321 {\r
322 \r
323 }\r
324 \r
325 CAtomDicti :: CAtomDicti( const CAtomDicti &c )\r
326 {\r
327         // copy constructor\r
328 \r
329         map<string, CAtom *> *pmapDicti = c.getValuePtr( );\r
330 \r
331         for( map<string, CAtom *> :: iterator i = pmapDicti->begin( ); i != pmapDicti->end( ); i++ )\r
332         {\r
333                 if( dynamic_cast<CAtomInt *>( (*i).second ) )\r
334                         setItem( (*i).first, new CAtomInt( *dynamic_cast<CAtomInt *>( (*i).second ) ) );\r
335                 else if( dynamic_cast<CAtomLong *>( (*i).second ) )\r
336                         setItem( (*i).first, new CAtomLong( *dynamic_cast<CAtomLong *>( (*i).second ) ) );\r
337                 else if( dynamic_cast<CAtomString *>( (*i).second ) )\r
338                         setItem( (*i).first, new CAtomString( *dynamic_cast<CAtomString *>( (*i).second ) ) );\r
339                 else if( dynamic_cast<CAtomList *>( (*i).second ) )\r
340                         setItem( (*i).first, new CAtomList( *dynamic_cast<CAtomList *>( (*i).second ) ) );\r
341                 else if( dynamic_cast<CAtomDicti *>( (*i).second ) )\r
342                         setItem( (*i).first, new CAtomDicti( *dynamic_cast<CAtomDicti *>( (*i).second ) ) );\r
343                 else\r
344                         UTIL_LogPrint( "error copying dictionary - found invalid atom, ignoring\n" );\r
345         }\r
346 }\r
347 \r
348 CAtomDicti :: ~CAtomDicti( )\r
349 {\r
350         clear( );\r
351 }\r
352 \r
353 int CAtomDicti :: EncodedLength( )\r
354 {\r
355         int iLen = 0;\r
356 \r
357         for( map<string, CAtom *> :: iterator i = m_mapDicti.begin( ); i != m_mapDicti.end( ); i++ )\r
358                 iLen += CAtomString( (*i).first ).EncodedLength( ) + (*i).second->EncodedLength( );\r
359 \r
360         return iLen + 2;\r
361 }\r
362 \r
363 int CAtomDicti :: Length( )\r
364 {\r
365         // nobody cares about you\r
366 \r
367         return 0;\r
368 }\r
369 \r
370 string CAtomDicti :: toString( )\r
371 {\r
372         return string( );\r
373 }\r
374 \r
375 bool CAtomDicti :: isEmpty( )\r
376 {\r
377         return m_mapDicti.empty( );\r
378 }\r
379 \r
380 void CAtomDicti :: clear( )\r
381 {\r
382         for( map<string, CAtom *> :: iterator i = m_mapDicti.begin( ); i != m_mapDicti.end( ); i++ )\r
383         {\r
384                 // UTIL_LogPrint( "deleting element %s\n", (*i).first.c_str( ) );\r
385 \r
386                 delete (*i).second;\r
387         }\r
388 \r
389         m_mapDicti.clear( );\r
390 }\r
391 \r
392 map<string, CAtom *> *CAtomDicti :: getValuePtr( ) const\r
393 {\r
394         return (map<string, CAtom *> *)&m_mapDicti;\r
395 }\r
396 \r
397 void CAtomDicti :: delItem( string strKey )\r
398 {\r
399         map<string, CAtom *> :: iterator i = m_mapDicti.find( strKey );\r
400 \r
401         if( i != m_mapDicti.end( ) )\r
402         {\r
403                 delete (*i).second;\r
404 \r
405                 m_mapDicti.erase( i );\r
406         }\r
407 }\r
408 \r
409 CAtom *CAtomDicti :: getItem( string strKey )\r
410 {\r
411         map<string, CAtom *> :: iterator i = m_mapDicti.find( strKey );\r
412 \r
413         if( i == m_mapDicti.end( ) )\r
414                 return NULL;\r
415         else\r
416                 return (*i).second;\r
417 }\r
418 \r
419 CAtom *CAtomDicti :: getItem( string strKey, CAtom *pReturn )\r
420 {\r
421         map<string, CAtom *> :: iterator i = m_mapDicti.find( strKey );\r
422 \r
423         if( i == m_mapDicti.end( ) )\r
424                 return pReturn;\r
425         else\r
426                 return (*i).second;\r
427 }\r
428 \r
429 void CAtomDicti :: setItem( string strKey, CAtom *pValue )\r
430 {\r
431         map<string, CAtom *> :: iterator i = m_mapDicti.find( strKey );\r
432 \r
433         if( i == m_mapDicti.end( ) )\r
434                 m_mapDicti.insert( pair<string, CAtom *>( strKey, pValue ) );\r
435         else\r
436         {\r
437                 delete (*i).second;\r
438 \r
439                 (*i).second = pValue;\r
440         }\r
441 }\r