src/OtherFunctions.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26 #ifndef OTHERFUNCTIONS_H
  27 #define OTHERFUNCTIONS_H
  28
  29 #include <wx/intl.h>            // Needed for wxLANGUAGE_ constants
  30
  31 #include "Types.h"              // Needed for uint16, uint32 and uint64
  32
  33 #include <algorithm>            // Needed for std::for_each     // Do_not_auto_remove (mingw-gcc-3.4.5)
  34
  35
  36 class CPath;
  37
  38
  39 /**
  40  * Helper function.
  41  *
  42  * @param ArgA The base value.
  43  * @param ArgB The value to compare ArgA against.
  44  * @return See below.
  45  *
  46  * Use this function to safely compare two arguments of a type that supports
  47  * the "<" operator. It works like strcmp and returns a negative value if ArgA
  48  * is less than ArgB, zero if ArgA is equal to ArgB and a positive value if
  49  * ArgA is greater than ArgB.
  50  */
  51 template <class TYPE>
  52 int CmpAny(const TYPE& ArgA, const TYPE& ArgB)
  53 {
  54         if ( ArgA < ArgB ) {
  55                 return -1;
  56         } else if ( ArgB < ArgA ) {
  57                 return  1;
  58         } else {
  59                 return  0;
  60         }
  61 }
  62
  63 //! Overloaded version of CmpAny for use with wxStrings.
  64 inline int CmpAny(const wxString& ArgA, const wxString& ArgB)
  65 {
  66         return ArgA.CmpNoCase( ArgB );
  67 }
  68
  69 //! Overloaded version of CmpAny for use with C-Strings (Unicoded).
  70 inline int CmpAny(const wxChar* ArgA, const wxChar* ArgB)
  71 {
  72         return wxString( ArgA ).CmpNoCase( ArgB );
  73 }
  74
  75
  76 /**
  77  * Removes the first instance of a value from a STL-like list: list, vector or deque.
  78  *
  79  * @param list The list to manipulate.
  80  * @param item The value to search for and remove.
  81  * @return The number of instances removed.
  82  */
  83 template <typename LIST, typename ITEM>
  84 unsigned int EraseFirstValue( LIST& list, const ITEM& item )
  85 {
  86         typename LIST::iterator it = list.begin();
  87
  88         for (; it != list.end(); ++it) {
  89                 if (*it == item) {
  90                         list.erase(it);
  91
  92                         return true;
  93                 }
  94         }
  95
  96         return false;
  97 }
  98
  99
 100 /**
 101  * Removes all instances of a value from a STL-like list: list, vector or deque.
 102  *
 103  * @param list The list to manipulate.
 104  * @param item The value to search for and remove.
 105  * @return The number of instances removed.
 106  */
 107 template <typename LIST, typename ITEM>
 108 unsigned int EraseValue( LIST& list, const ITEM& item )
 109 {
 110         typename LIST::iterator it = list.begin();
 111         unsigned int count = 0;
 112
 113         for ( ; it != list.end(); ) {
 114                 if ( *it == item ) {
 115                         it = list.erase( it );
 116                         count++;
 117                 } else {
 118                         ++it;
 119                 }
 120         }
 121
 122         return count;
 123 }
 124
 125
 126 //! Used by DeleteContents
 127 struct SDoDelete
 128 {
 129         // Used for lists, vectors, deques, etc.
 130         template <typename TYPE>
 131         void operator()(TYPE* ptr) {
 132                 delete ptr;
 133         }
 134
 135         // Used for maps, hashmaps, rangemaps, etc.
 136         template <typename FIRST, typename SECOND>
 137         void operator()(const std::pair<FIRST, SECOND>& pair) {
 138                 delete pair.second;
 139         }
 140 };
 141
 142
 143 /** Frees the contents of a list or map like stl container, clearing it afterwards. */
 144 template <typename STL_CONTAINER>
 145 void DeleteContents(STL_CONTAINER& container)
 146 {
 147         // Ensure that the actual container wont contain dangling pointers during
 148         // this operation, to ensure that the destructors cant access them.
 149         STL_CONTAINER copy;
 150
 151         std::swap(copy, container);
 152         std::for_each(copy.begin(), copy.end(), SDoDelete());
 153 }
 154
 155
 156 /**
 157  * Copies elements from the range [first, first + n) to the range [result, result + n).
 158  */
 159 template <class InputIterator, class OutputIterator>
 160 OutputIterator STLCopy_n(InputIterator first, size_t n, OutputIterator result)
 161 {
 162         return std::copy(first, first + n, result);
 163 }
 164
 165
 166 /**
 167  * Returns a description of the version of aMule being used.
 168  *
 169  * @return A detailed description of the aMule version, including wx information.
 170  *
 171  * Use this rather than just using the VERSION or CURRENT_VERSION_LONG
 172  * constants, when displaying information to the user. The purpose is to
 173  * help with debugging.
 174  */
 175 wxString GetMuleVersion();
 176
 177 /**
 178  * This functions is like the GetMuleVersion function above, with the exception
 179  * that it also includes the name of the application. This can be one of the
 180  * following:
 181  *
 182  *  - aMule
 183  *  - aMuled
 184  *  - Remote aMule-GUI
 185  */
 186 wxString GetFullMuleVersion();
 187
 188
 189 /**
 190  * Helperfunction for accessing a child of the calling widget.
 191  *
 192  * @param IdOrName The ID or the Name of the widget to find.
 193  * @param type The widget-type to cast the found widget to.
 194  *
 195  * Use this function as a replacement for the following constructs:
 196  *  - wxStaticCast( FindWindow( <IdOrName> ), <type> )
 197  *  - (<type>*)FindWindow( <IdOrName> )
 198  *
 199  * It has the advantage of validating the cast in debug builds and being much
 200  * shorter than than manually typing wxStaticCast + FindWindow. This mean that
 201  * we will be alerted in case of widget changing type, instead of getting just
 202  * getting bad mojo due to casting a pointer to the wrong type.
 203  */
 204 #define CastChild( IdOrName, type )                     dynamic_cast<type*>( FindWindow( IdOrName ) )
 205
 206
 207 /**
 208  * Helperfunction for accessing the child of a any widget by ID.
 209  *
 210  * @param ID The ID of the widget to find.
 211  * @param parent The parent of the widget to find, or NULL to search from the top.
 212  * @param type The type to cast the widget to.
 213  *
 214  * @see CastChild()
 215  */
 216 #define CastByID( ID, parent, type )            dynamic_cast<type*>( wxWindow::FindWindowById( (ID), (parent) ) )
 217
 218
 219 /**
 220  * Helperfunction for accessing the child of a any widget by Name.
 221  *
 222  * @param Name The Name of the widget to find.
 223  * @param parent The parent of the widget to find, or NULL to search from the top.
 224  * @param type The type to cast the widget to.
 225  *
 226  * @see CastChild()
 227  */
 228 #define CastByName( Name, parent, type )        dynamic_cast<type*>( wxWindow::FindWindowByName( (Name), (parent) ) )
 229
 230
 231 // From Gnucleus project [found by Tarod]
 232 // Base16/Base32/Base64 Encode/Decode functions
 233 wxString EncodeBase16(const unsigned char* buffer, unsigned int bufLen);
 234 unsigned int DecodeBase16(const wxString &base16Buffer, unsigned int base16BufLen, unsigned char *buffer);
 235 wxString EncodeBase32(const unsigned char* buffer, unsigned int bufLen);
 236 unsigned int DecodeBase32(const wxString &base32Buffer, unsigned int base32BufLen, unsigned char *buffer);
 237 wxString EncodeBase64(const char* buffer, unsigned int bufLen);
 238 unsigned int DecodeBase64(const wxString &base64Buffer, unsigned int base64BufLen, unsigned char *buffer);
 239
 240 // Converts the number of bytes to human readable form.
 241 wxString CastItoXBytes(uint64 count);
 242 // Converts the number to human readable form, abbreviating when nessecary.
 243 wxString CastItoIShort(uint64 number);
 244 // Converts a number of bytes to a human readable speed value.
 245 wxString CastItoSpeed(uint32 bytes);
 246 // Converts an amount of seconds to human readable time.
 247 wxString CastSecondsToHM(uint64 seconds, uint16 msecs = 0);
 248 // Returns the amount of Bytes the provided size-type represents
 249 uint32 GetTypeSize(uint8 type);
 250 // Returns the string associated with a file-rating value.
 251 wxString GetRateString(uint16 rate);
 252
 253
 254 // The following functions are used to identify and/or name the type of a file
 255 enum FileType { ftAny, ftVideo, ftAudio, ftArchive, ftCDImage, ftPicture, ftText, ftProgram };
 256 // Examins a filename and returns the enumerated value assosiated with it, or ftAny if unknown extension
 257 FileType GetFiletype(const CPath& filename);
 258 // Returns the description of a filetype: Movies, Audio, Pictures and so on...
 259 wxString GetFiletypeDesc(FileType type, bool translated = true);
 260 // Shorthand for GetFiletypeDesc(GetFiletype(filename))
 261 wxString GetFiletypeByName(const CPath& filename, bool translated = true);
 262
 263
 264 // Returns the name associated with a category value.
 265 wxString GetCatTitle(int catid);
 266
 267 /* Other */
 268
 269
 270 //! Returns the number of items in an array.
 271 #define itemsof(x) (sizeof(x)/sizeof(x[0]))
 272
 273
 274 ///////////////////////////////////////////////////////////////////////////////
 275 // ED2K File Type
 276 //
 277
 278 enum EED2KFileType
 279 {
 280         ED2KFT_ANY,
 281         ED2KFT_AUDIO,
 282         ED2KFT_VIDEO,
 283         ED2KFT_IMAGE,
 284         ED2KFT_PROGRAM,
 285         ED2KFT_DOCUMENT,
 286         ED2KFT_ARCHIVE,
 287         ED2KFT_CDIMAGE
 288 };
 289
 290 class EED2KFileTypeClass
 291 {
 292 public:
 293         EED2KFileTypeClass()
 294         {
 295                 s_t = ED2KFT_ANY;
 296         }
 297         EED2KFileTypeClass(EED2KFileType t)
 298         {
 299                 s_t = t;
 300         }
 301         EED2KFileType GetType() const
 302         {
 303                 return s_t;
 304         }
 305
 306 private:
 307         EED2KFileType s_t;
 308 };
 309
 310 EED2KFileType GetED2KFileTypeID(const CPath& fileName);
 311 wxString GetED2KFileTypeSearchTerm(EED2KFileType iFileID);
 312 wxString GetFileTypeByName(const CPath& fileName);
 313 EED2KFileType GetED2KFileTypeSearchID(EED2KFileType iFileID);
 314 ///////////////////////////////////////////////////////////////////////////////
 315
 316 // md4cmp -- replacement for memcmp(hash1,hash2,16)
 317 // Like 'memcmp' this function returns 0, if hash1==hash2, and !0, if hash1!=hash2.
 318 // NOTE: Do *NOT* use that function for determining if hash1<hash2 or hash1>hash2.
 319 inline int md4cmp(const void* hash1, const void* hash2)
 320 {
 321         return memcmp(hash1, hash2, 16);
 322 }
 323
 324
 325 // md4clr -- replacement for memset(hash,0,16)
 326 inline void md4clr(void* hash)
 327 {
 328         memset(hash, 0, 16);
 329 }
 330
 331
 332 // md4cpy -- replacement for memcpy(dst,src,16)
 333 inline void md4cpy(void* dst, const void* src)
 334 {
 335         memcpy(dst, src, 16);
 336 }
 337
 338
 339 // DumpMem ... Dumps mem ;)
 340 wxString DumpMemToStr(const void *buff, int n, const wxString& msg = wxEmptyString, bool ok = true);
 341 void DumpMem(const void *buff, int n, const wxString& msg = wxEmptyString, bool ok = true);
 342 void DumpMem_DW(const uint32 *ptr, int count);
 343
 344 // Returns special source ID for GUI.
 345 // It's actually IP<<16+Port
 346 #define GUI_ID(x,y) (uint64)((((uint64)x)<<16) + (uint64)y)
 347 // And so...
 348 #define PORT_FROM_GUI_ID(x) (x & 0xFFFF)
 349 #define IP_FROM_GUI_ID(x) (x >> 16)
 350
 351
 352
 353 inline long int make_full_ed2k_version(int a, int b, int c) {
 354         return ((a << 17) | (b << 10) | (c << 7));
 355 }
 356
 357
 358 wxString GetConfigDir();
 359
 360 #define  wxLANGUAGE_CUSTOM              wxLANGUAGE_USER_DEFINED+1
 361 #define  wxLANGUAGE_ITALIAN_NAPOLITAN   wxLANGUAGE_USER_DEFINED+2
 362
 363 /**
 364  * Adds aMule's custom languages to db.
 365  */
 366 void InitCustomLanguages();
 367
 368 /**
 369  * Initializes locale
 370  */
 371 void InitLocale(wxLocale& locale, int language);
 372
 373 /**
 374  * Converts a string locale definition to a wxLANGUAGE id.
 375  */
 376 int StrLang2wx(const wxString& language);
 377
 378 /**
 379  * Converts a wxLANGUAGE id to a string locale name.
 380  */
 381 wxString wxLang2Str(const int lang);
 382
 383 /**
 384  * Generate MD5Hash of prompt input
 385  */
 386 wxString GetPassword();
 387
 388
 389 #if wxUSE_THREADS
 390
 391 #include <wx/thread.h>
 392
 393 /**
 394  * Automatically unlocks a mutex on construction and locks it on destruction.
 395  *
 396  * This class is the complement of wxMutexLocker.  It is intended to be used
 397  * when a mutex, which is locked for a period of time, needs to be
 398  * temporarily unlocked for a bit.  For example:
 399  *
 400  *      wxMutexLocker lock(mutex);
 401  *
 402  *      // ... do stuff that requires that the mutex is locked ...
 403  *
 404  *      {
 405  *              CMutexUnlocker unlocker(mutex);
 406  *              // ... do stuff that requires that the mutex is unlocked ...
 407  *      }
 408  *
 409  *      // ... do more stuff that requires that the mutex is locked ...
 410  *
 411  */
 412 class CMutexUnlocker
 413 {
 414 public:
 415     // unlock the mutex in the ctor
 416     CMutexUnlocker(wxMutex& mutex)
 417         : m_isOk(false), m_mutex(mutex)
 418         { m_isOk = ( m_mutex.Unlock() == wxMUTEX_NO_ERROR ); }
 419
 420     // returns true if mutex was successfully unlocked in ctor
 421     bool IsOk() const
 422         { return m_isOk; }
 423
 424     // lock the mutex in dtor
 425     ~CMutexUnlocker()
 426         { if ( IsOk() ) m_mutex.Lock(); }
 427
 428 private:
 429     // no assignment operator nor copy ctor
 430     CMutexUnlocker(const CMutexUnlocker&);
 431     CMutexUnlocker& operator=(const CMutexUnlocker&);
 432
 433     bool     m_isOk;
 434     wxMutex& m_mutex;
 435 };
 436 #endif /* wxUSE_THREADS */
 437
 438
 439 #endif // OTHERFUNCTIONS_H
 440 // File_checked_for_headers