src/OtherFunctions.h

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