include/MUtils/Global.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // MuldeR's Utilities for Qt
   3 // Copyright (C) 2004-2018 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This library is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU Lesser General Public
   7 // License as published by the Free Software Foundation; either
   8 // version 2.1 of the License, or (at your option) any later version.
   9 //
  10 // This library is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // Lesser General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Lesser General Public
  16 // License along with this library; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18 //
  19 // http://www.gnu.org/licenses/lgpl-2.1.txt
  20 //////////////////////////////////////////////////////////////////////////////////
  21
  22 /**
  23  * @file
  24  * @brief This file contains miscellaneous functions that are generally useful for Qt-based applications
  25  */
  26
  27 #pragma once
  28
  29 #include <QString>
  30
  31 //Forward Declarations
  32 class QProcess;
  33 class QDir;
  34 template<typename K, typename V> class QHash;
  35
  36 ///////////////////////////////////////////////////////////////////////////////
  37
  38 /** \cond INTERNAL
  39  */
  40
  41 //MUtils API
  42 #ifdef _MSC_VER
  43 #       ifdef MUTILS_DLL_EXPORT
  44 #               define MUTILS_API __declspec(dllexport)
  45 #       else
  46 #               ifndef MUTILS_STATIC_LIB
  47 #                       define MUTILS_API __declspec(dllimport)
  48 #               else
  49 #                       define MUTILS_API /*static lib*/
  50 #               endif
  51 #       endif
  52 #else
  53 #       define MUTILS_API
  54 #endif
  55
  56 #define MUTILS_MAKE_STRING_HELPER(X) #X
  57 #define MUTILS_MAKE_STRING(X) MUTILS_MAKE_STRING_HELPER(X)
  58 #define MUTILS_COMPILER_WARNING(TXT) __pragma(message(__FILE__ "(" MUTILS_MAKE_STRING(__LINE__) ") : warning: " TXT))
  59
  60 //Check Debug Flags
  61 #if defined(_DEBUG) || defined(DEBUG) || (!defined(NDEBUG))
  62 #       define MUTILS_DEBUG (1)
  63 #       if defined(NDEBUG) || defined(QT_NO_DEBUG) || (!defined(QT_DEBUG))
  64 #               error Inconsistent DEBUG flags have been detected!
  65 #       endif
  66 #else
  67 #       define MUTILS_DEBUG (0)
  68 #       if (!defined(NDEBUG)) || (!defined(QT_NO_DEBUG)) || defined(QT_DEBUG)
  69 #               error Inconsistent DEBUG flags have been detected!
  70 #       endif
  71 #endif
  72
  73 //Check CPU options
  74 #if defined(_MSC_VER) && (!defined(__INTELLISENSE__)) && (!defined(_M_X64)) && defined(_M_IX86_FP)
  75         #if (_M_IX86_FP != 0)
  76                 #error We should not enabled SSE or SSE2 in release builds!
  77         #endif
  78 #endif
  79
  80 /** \endcond INTERNAL
  81  */
  82
  83 ///////////////////////////////////////////////////////////////////////////////
  84
  85 /**
  86 * \brief Global MUtils namespace
  87 */
  88 namespace MUtils
  89 {
  90         /**
  91         * \brief This struct containes the parts (integral and fractional part) of a floating-point number
  92         */
  93         typedef struct _fp_parts_t { double parts[2]; } fp_parts_t;
  94
  95         /**
  96         * \brief Rerieves the full path of the application's *Temp* folder.
  97         *
  98         * The application's *Temp* folder is a unique application-specific folder, intended to store any temporary files that the application may need. It will be created when this function is called for the first time (lazy initialization); subsequent calls are guaranteed to return the same path. Usually the application's *Temp* folder will be created as a sub-folder of the system's global *Temp* folder, as indicated by the `TMP` or `TEMP` environment variables. However, it may be created at a different place (e.g. in the users *Profile* directory), if those environment variables don't point to a usable directory. In any case, this function makes sure that the application's *Temp* folder exists for the whole lifetime of the application and that it is writable. When the application terminates normally, the application's *Temp* folder and all files or sub-directories thereof will be *removed* automatically!
  99         *
 100         * \return If the function succeeds, it returns a read-only reference to a QString holding the full path of the application's *Temp* folder; otherwise a read-only reference to a default-constructed QString is returned.
 101         */
 102         MUTILS_API const QString& temp_folder(void);
 103
 104         /**
 105         * \brief Initialize a given [QProcess](http://doc.qt.io/qt-4.8/qprocess.html) object.
 106         *
 107         * This function prepares a given [QProcess](http://doc.qt.io/qt-4.8/qprocess.html) object for sub-process creation. It does so by setting up combined *stdout* and *stderr* redirection for the sub-process, cleaning up the sub-process' environment variables, as well as setting up the sub-process' working directory. Optionally, the *Temp* directory for the sub-process can be set to the application-specific *Temp* directory, which is achieved by overwriting the corresponding environment variables (e.g. `TMP` and `TEMP`). Furthermore, additional paths can be added to the `PATH` environment variable of the sub-process.
 108         *
 109         * \param process A reference to the [QProcess](http://doc.qt.io/qt-4.8/qprocess.html) object to be initialized. The [QProcess](http://doc.qt.io/qt-4.8/qprocess.html) object must be initialized *before* calling the `QProcess::start()` method.
 110         *
 111         * \param process A read-only reference to a QString holding the path of the working directory for the sub-process.
 112         *
 113         * \param bReplaceTempDir If set to `true`, the *Temp* directory for the sub-process is set to the application-specific *Temp* directory; if set to `false`, the default *Temp* directory is retained.
 114         *
 115         * \param extraPaths A read-only pointer to a QStringList object containing additional paths that will be added (prepended) to the sub-process' `PATH` environment variable. This parameter can be `NULL`, in which case *no* additional paths are added.
 116         */
 117         MUTILS_API void init_process(QProcess &process, const QString &wokringDir, const bool bReplaceTempDir = true, const QStringList *const extraPaths = NULL, const QHash<QString, QString> *const extraEnv = NULL);
 118
 119         /**
 120         * \brief Generates a *random* unsigned 32-Bit value.
 121         *
 122         * The *random* value is created using a "strong" PRNG of the underlying system, if possible. Otherwise a fallback PRNG is used. It is **not** required or useful to call `srand()` or `qsrand()` prior to using this function. If necessary, the seeding of the PRNG happen *automatically* on the first call.
 123         *
 124         * \return The function returns a *random* unsigned 32-Bit value.
 125         */
 126         MUTILS_API quint32 next_rand_u32(void);
 127         MUTILS_API quint32 next_rand_u32(const quint32 max);
 128
 129         /**
 130         * \brief Generates a *random* unsigned 64-Bit value.
 131         *
 132         * The *random* value is created using a "strong" PRNG of the underlying system, if possible. Otherwise a fallback PRNG is used. It is **not** required or useful to call `srand()` or `qsrand()` prior to using this function. If necessary, the seeding of the PRNG happen *automatically* on the first call.
 133         *
 134         * \return The function returns a *random* unsigned 64-Bit value.
 135         */
 136         MUTILS_API quint64 next_rand_u64(void);
 137
 138         /**
 139         * \brief Generates a *random* string.
 140         *
 141         * The random string is generated using the same PRNG as the `next_rand_u64()` function. The *random* bytes are converted to a hexadecimal string and, if necessary, zero-padded to a toal length of 16 or 32 characters. There is **no** `0x`-prefix included in the result.
 142         *
 143         * \param bLong If set to `true`, a "long" random string (32 characters) will be generated; if set to `false`, a "short" random string (16 characters) is generated.
 144         *
 145         * \return The function returns a QString holding a *random* hexadecimal string
 146         */
 147         MUTILS_API QString next_rand_str(const bool &bLong = false);
 148
 149         /**
 150         * \brief Generates a temporary file name.
 151         *
 152         * The function generates a file name that contains a *random* component and that is guaranteed to **not** exist yet. The generated file name follows a `"<basedir>/<random>.<ext>"` pattern. This is useful (not only) for creating temporary files.
 153         *
 154         * \param basePath Specifies the "base" directory where the temporary file is supposed to be created. This must be a valid *existing* directory.
 155         *
 156         * \param extension Specifies the desired file extensions of the temporary file. Do **not** include a leading dot (`.`) character.
 157         *
 158         * \param placeholder If set to `true`, the function creates an empty "placeholder" file under the returned file name; if set to `false`, it does *not*.
 159         *
 160         * \return If the function succeeds, it returns a QString holding the full path of the temporary file; otherwise it returns a default-constructed QString.
 161         */
 162         MUTILS_API QString make_temp_file(const QString &basePath, const QString &extension, const bool placeholder = false);
 163         MUTILS_API QString make_temp_file(const QDir    &basePath, const QString &extension, const bool placeholder = false);
 164
 165         /**
 166         * \brief Generates a unique file name.
 167         *
 168         * The function generates a unique file name in the specified directory. The function guarantees that the returned file name does *not* exist yet. If necessary, a *counter* will be included in the file name in order to ensure its uniqueness.
 169         *
 170         * \param basePath Specifies the "base" directory where the unique file is supposed to be created. This must be a valid *existing* directory.
 171         *
 172         * \param baseName Specifies the desired "base" file name of the unique file. Do **not** include a file extension.
 173         *
 174         * \param extension Specifies the desired file extensions of the unique file. Do **not** include a leading dot (`.`) character.
 175         *
 176         * \param fancy If set to `true`, the unique file name is generated according to the `"<basedir>/<basename> (N).<ext>"` pattern; if set to `false`, it is generated according to the `"<basedir>/<basename>.XXXX.<ext>"` pattern. Also, if set to `true`, a counter is only included in the file name, if the file name *without* counter already exists; if set to `false`, a counter is always included. Finally, if set to `true`, the counter starts at **2** and is printed in decimal format; if set to `false`, the counter starts at **0** and is printed in zero-padded hexadecimal format.
 177         *
 178         * \return If the function succeeds, it returns a QString holding the full path of the unique file; otherwise it returns a default-constructed QString.
 179         */
 180         MUTILS_API QString make_unique_file(const QString &basePath, const QString &baseName, const QString &extension, const bool fancy = false, const bool placeholder = false);
 181         MUTILS_API QString make_unique_file(const QDir    &basePath, const QString &baseName, const QString &extension, const bool fancy = false, const bool placeholder = false);
 182
 183         /**
 184         * \brief Computes the *parity* of the given unsigned 32-Bit value
 185         *
 186         * \param value The 32-Bit unsigned value from which the parity is to be computed.
 187         *
 188         * \return The function returns `true`, if the number of **1** bits in the given value is *odd*; it returns `false`, if the number of **1** bits in the given value is *even*.
 189         */
 190         MUTILS_API bool parity(quint32 value);
 191
 192         /**
 193         * \brief Deletes the specified file
 194         *
 195         * The function deletes the specified file, even if it has the "read only" flag set. If the file is currently locked (e.g. by another process), the function retries multiple times to delete the file before it fails.
 196         *
 197         * \param fileName The path to the file to be deleted. This should be a full path.
 198         *
 199         * \return The function returns `true`, if the file was deleted successfully or if the file doesn't exist; it returns `false`, if the file could *not* be deleted.
 200         */
 201         MUTILS_API bool remove_file(const QString &fileName);
 202
 203         /**
 204         * \brief Recursively deletes the specified directory
 205         *
 206         * The function deletes the specified directory. In *recursive* mode, the directory will be removed including all of its files and sub-directories. Files are deleted using the `remove_file()` function.
 207         *
 208         * \param folderPath The path to the directory to be deleted. This should be a full path.
 209         *
 210         * \param recursive If set to `true` the function removes all files and sub-directories in the specified directory; if set to `false`, the function will *not* try to delete any files or sub-directories, which means that it will fail on non-empty directories.
 211         *
 212         * \return The function returns `true`, if the directory was deleted successfully or if the directory doesn't exist; it returns `false`, if the directory could *not* be deleted.
 213         */
 214         MUTILS_API bool remove_directory(const QString &folderPath, const bool &recursive);
 215
 216         /**
 217         * \brief Remove *trailing* white-space characters
 218         *
 219         * The function removes all *trailing* white-space characters from the specified string. Leading white-space characters are *not* removed. White-space characters are defined by the `\s` character class.
 220         *
 221         * \param str A reference to the QString object to be trimmed. This QString object will be modified directly.
 222         *
 223         * \return A reference to the trimmed QString object. This is the same QString object that was specified in the `str` parameter.
 224         */
 225         MUTILS_API QString& trim_right(QString &str);
 226
 227         /**
 228         * \brief Remove *leading* white-space characters
 229         *
 230         * The function removes all *leading* white-space characters from the specified string. Trailing white-space characters are *not* removed. White-space characters are defined by the `\s` character class.
 231         *
 232         * \param str A reference to the QString object to be trimmed. This QString object will be modified directly.
 233         *
 234         * \return A reference to the trimmed QString object. This is the same QString object that was specified in the `str` parameter.
 235         */
 236         MUTILS_API QString& trim_left(QString &str);
 237
 238         /**
 239         * \brief Remove *trailing* white-space characters
 240         *
 241         * The function removes all *trailing* white-space characters from the specified string. Leading white-space characters are *not* removed. White-space characters are defined by the `\s` character class.
 242         *
 243         * \param str A read-only reference to the QString object to be trimmed. The original QString object is *not* modified.
 244         *
 245         * \return A new QString object that equals the original QString object, except that it has all *trailing* white-space characters removed.
 246         */
 247         MUTILS_API QString trim_right(const QString &str);
 248
 249         /**
 250         * \brief Remove *trailing* white-space characters
 251         *
 252         * The function removes all *leading* white-space characters from the specified string. Trailing white-space characters are *not* removed. White-space characters are defined by the `\s` character class.
 253         *
 254         * \param str A read-only reference to the QString object to be trimmed. The original QString object is *not* modified.
 255         *
 256         * \return A new QString object that equals the original QString object, except that it has all *leading* white-space characters removed.
 257         */
 258         MUTILS_API QString trim_left(const QString &str);
 259
 260         /**
 261         * \brief Sort a list of strings using "natural ordering" algorithm
 262         *
 263         * This function implements a sort algorithm that orders alphanumeric strings in the way a human being would. See [*Natural Order String Comparison*](http://sourcefrog.net/projects/natsort/) for details!
 264         *
 265         * \param list A reference to the QStringList object to be sorted. The list will be sorted "in place".
 266         *
 267         * \param bIgnoreCase If set to `true`, the list will be sorted disregarding the character case, i.e. upper-case and lower-case characters (of the same letter) are treated the same; if set to `false`, the character case *is* taken into account.
 268         */
 269         MUTILS_API void natural_string_sort(QStringList &list, const bool bIgnoreCase);
 270
 271         /**
 272         * \brief Clean up a file name string
 273         *
 274         * This function ensures that the given string is a valid file (or directory) name. It does so by replacing any illegal characters, i.e. any characters *not* allowed in file names (which explicitly *includes* directory separators). Furthermore, the function will trim/remove specific characters that are *not* allowed directly at the beginning or end of a file name. Finally, the function takes care of special "reserved" file names that are forbidden by the file system. You can use this function to convert user inputs into a valid file name.
 275         *
 276         * \param name A read-only reference to the QString holding the original, potentially invalid file name.
 277         *
 278         * \param pretty If set to `true`, the function tries to generate a "pretty" file name from the given file name. Otherwise, the function simply replaces each forbidden file name character by an underscore character.
 279         *
 280         * \return The function returns a QString holding a valid file name. If, however, the input string was empty or contained only white-space characters, the returned sting can be empty.
 281         */
 282         MUTILS_API QString clean_file_name(const QString &name, const bool &pretty);
 283
 284         /**
 285         * \brief Clean up a file path string
 286         *
 287         * This function ensures that the given string is a valid file (or directory) path. It does so by replacing any illegal characters, i.e. any characters *not* allowed in file paths. Directory separators are preserved, but they will be "canonicalized". Furthermore, in each path component, the function will trim/remove specific characters that are *not* allowed directly at the beginning or end of a path component. Finally, the function takes care of special "reserved" file names that are forbidden by the file system. You can use this function to convert user inputs into a valid file path.
 288         *
 289         * \param path A read-only reference to the QString holding the original, potentially invalid file path.
 290         *
 291         * \param pretty If set to `true`, the function tries to generate "pretty" file names from the given file names. Otherwise, the function simply replaces each forbidden file name character by an underscore character.
 292         *
 293         * \return The function returns a QString holding a valid file path. If, however, the input string was empty or contained only white-space characters, the returned sting can be empty.
 294         */
 295         MUTILS_API QString clean_file_path(const QString &path, const bool &pretty);
 296
 297         /**
 298         * \brief Parse regular expression results
 299         *
 300         * This function tries to parses the result (capture) of a regular expression as an unsigned 32-Bit value. The given regular expression must contain at least *one* capture. Only the *first* capture is considered, additional captures are ignored.
 301         *
 302         * \param regexp A read-only reference to the [QRegExp](http://doc.qt.io/qt-4.8/qregexp.html) object whose result (capture) will be parsed. This [QRegExp](http://doc.qt.io/qt-4.8/qregexp.html) must already have been *successfully* matched against the respective input string, e.g. via `QRegExp::indexIn()`, prior to calling this function.
 303         *
 304         * \param value A reference to a variable of type `quint32`, where the unsigned 32-Bit representation of the result will be stored. The contents of this variable are *undefined*, if the function failed.
 305         *
 306         * \return The function returns `true`, if the regular expression's capture could be parsed successfully; it returns `false`, if the capture contains an invalid string or if there are insufficient captures in given the [QRegExp](http://doc.qt.io/qt-4.8/qregexp.html) object.
 307         */
 308         MUTILS_API bool regexp_parse_uint32(const QRegExp &regexp, quint32 &value);
 309         MUTILS_API bool regexp_parse_int32(const QRegExp &regexp, qint32 &value);
 310         MUTILS_API bool regexp_parse_uint32(const QRegExp &regexp, quint32 &value, const size_t &offset);
 311         MUTILS_API bool regexp_parse_int32(const QRegExp &regexp, qint32 &value, const size_t &offset);
 312
 313         /**
 314         * \brief Parse regular expression results
 315         *
 316         * This function tries to parses the results (captures) of a regular expression as unsigned 32-Bit values. The given regular expression must contain at least \p count captures. Only the *first* \p count captures are considered, additional captures are ignored.
 317         *
 318         * \param regexp A read-only reference to the [QRegExp](http://doc.qt.io/qt-4.8/qregexp.html) object whose results (captures) will be parsed. This [QRegExp](http://doc.qt.io/qt-4.8/qregexp.html) must already have been *successfully* matched against the respective input string, e.g. via `QRegExp::indexIn()`, prior to calling this function.
 319         *
 320         * \param value A pointer to an array of type `quint32`, where the unsigned 32-Bit representations of the results will be stored (the `n`-th result is stored at `value[n-1]`). The array must be at least \p count elements in length. The contents of this array are *undefined*, if the function failed.
 321         *
 322         * \param count Specifies the number of results (captures) in the given [QRegExp](http://doc.qt.io/qt-4.8/qregexp.html) object. The function tries to parse the first \p count captures and ignores any additional captures that may exist. This parameter also determines the required (minimum) length of the \p value array.
 323         *
 324         * \return The function returns `true`, if all of the regular expression's captures could be parsed successfully; it returns `false`, if any of the captures contain an invalid string or if there are insufficient captures in given the [QRegExp](http://doc.qt.io/qt-4.8/qregexp.html) object.
 325         */
 326         MUTILS_API bool regexp_parse_uint32(const QRegExp &regexp, quint32 *values, const size_t &count);
 327         MUTILS_API bool regexp_parse_int32(const QRegExp &regexp, qint32 *values, const size_t &count);
 328         MUTILS_API bool regexp_parse_uint32(const QRegExp &regexp, quint32 *values, const size_t &offset, const size_t &count);
 329         MUTILS_API bool regexp_parse_int32(const QRegExp &regexp, qint32 *values, const size_t &offset, const size_t &count);
 330
 331         /**
 332         * \brief Retrieve a list of all available codepages
 333         *
 334         * The function generates a list of all codepages that are available on the system. Each codepage name returned by this function may be passed to the `QTextCodec::codecForName()` function in order to obtain a corresponding [QTextCodec](http://doc.qt.io/qt-4.8/qtextcodec.html) object.
 335         *
 336         * \param noAliases If set to `true`, only distinct codepages are returned, i.e. any codepage aliases are discarded from the list; if set to `false`, the returned list may (and usually will) also contain codepage aliases.
 337         *
 338         * \return If the function succeeds, it returns a QStringList holding the names of all codepages available on the system; otherwise it returns a default-constructed QStringList.
 339         */
 340         MUTILS_API QStringList available_codepages(const bool &noAliases = true);
 341
 342         /**
 343         * \brief Break floating-point number into fractional and integral parts
 344         *
 345         * The function returns a struct containing the fractional and the integral part of a given floating-point values as two separate values. This is a convenience warapper for the `modf()` function.
 346         *
 347         * \param value The original floating-point value
 348         *
 349         * \return Returns a struct containing the fractional and integral parts.
 350         */
 351         MUTILS_API fp_parts_t break_fp(const double value);
 352
 353         //Internal
 354         namespace Internal
 355         {
 356                 MUTILS_API int selfTest(const char *const buildKey, const bool debug);
 357                 static const int s_selfTest = selfTest(__DATE__ "@" __TIME__, MUTILS_DEBUG);
 358         }
 359 }
 360
 361 ///////////////////////////////////////////////////////////////////////////////
 362
 363 /** \brief Deletes the object, if and only if the given pointer is *not* NULL. Also sets pointer to NULL after object has been deleted.
 364 */
 365 #define MUTILS_DELETE(PTR) do { if((PTR)) { delete (PTR); (PTR) = NULL; } } while(0)
 366
 367 /** \brief Deletes the array, if and only if the given pointer is *not* NULL. Also sets pointer to NULL after array has been deleted.
 368 */
 369 #define MUTILS_DELETE_ARRAY(PTR) do { if((PTR)) { delete [] (PTR); (PTR) = NULL; } } while(0)
 370
 371 /** \brief Clears the specified variable or struct by setting all of its bytes to *zero* (`0x00`). Do **not** use for arrays.
 372 */
 373 #define MUTILS_ZERO_MEMORY(PTR) memset(&(PTR), 0, sizeof((PTR)))
 374
 375 /** \brief Converts a given QString object to a `wchar_t*` pointer. Does **not** copy the string data, so do **not** free the pointer! The returned pointer only remains valid until the underlying QString is modified or goes out of scope.
 376 */
 377 #define MUTILS_WCHR(STR) (reinterpret_cast<const wchar_t*>((STR).utf16()))
 378
 379 /** \brief Converts a given QString object to a `char*` pointer. The string is converted to UTF-8 encoding. The pointer is valid *only* while the expression is being evaluated, so do **not** free or store this pointer! Mainly useful for function calls that require a `char*` argument.
 380 */
 381 #define MUTILS_UTF8(STR) ((STR).toUtf8().constData())
 382
 383 /** \brief Converts a given QString object to a `char*` pointer. The string is converted to Latin-1 encoding. The pointer is valid *only* while the expression is being evaluated, so do **not** free or store this pointer! Mainly useful for function calls that require a `char*` argument.
 384 */
 385 #define MUTILS_L1STR(STR) ((STR).toLatin1().constData())
 386
 387 /** \brief Creates a QString object from a given `wchar_t*` buffer. The buffer is expected to conatin a NULL-terminated string in UTF-16 encoding. The string data is copied into the new QString object, however the original buffer will **not** be freed automatically!
 388 */
 389 #define MUTILS_QSTR(STR) (QString::fromUtf16(reinterpret_cast<const unsigned short*>((STR))))
 390
 391 /** \brief Converts a boolean expression into a string. A *true* boolean expression is converted to the string `"1"`; a *false* boolean expression is converted to the string `"0"`.
 392 */
 393 #define MUTILS_BOOL2STR(X) ((X) ? "1" : "0")
 394
 395 /** \brief Converts a given expression into a boolean expression, by application of double negation operator.
 396 */
 397 #define MUTILS_BOOLIFY(X) (!(!(X)))
 398
 399 /** \brief Get length of an array, only works with local array variables!
 400 */
 401 #define MUTILS_ARR2LEN(X) (sizeof((X)) / sizeof((X)[0]))
 402
 403 /** \brief Disables copy constructor and assignment operator in the specified class. This macro should be used in the "private" section of the class' declaration.
 404 */
 405 #define MUTILS_NO_COPY(CLASS) \
 406         CLASS(const CLASS &) { throw "Copy constructor is disabled!"; } \
 407         CLASS &operator=(const CLASS &) { throw "Assignment operator is disabled!"; }