The MRPT project: utils_defs.h Source File

Go to the documentation of this file.
00001 /* +---------------------------------------------------------------------------+
00002    |          The Mobile Robot Programming Toolkit (MRPT) C++ library          |
00003    |                                                                           |
00004    |                   http://mrpt.sourceforge.net/                            |
00005    |                                                                           |
00006    |   Copyright (C) 2005-2010  University of Malaga                           |
00007    |                                                                           |
00008    |    This software was written by the Machine Perception and Intelligent    |
00009    |      Robotics Lab, University of Malaga (Spain).                          |
00010    |    Contact: Jose-Luis Blanco  <jlblanco@ctima.uma.es>                     |
00011    |                                                                           |
00012    |  This file is part of the MRPT project.                                   |
00013    |                                                                           |
00014    |     MRPT is free software: you can redistribute it and/or modify          |
00015    |     it under the terms of the GNU General Public License as published by  |
00016    |     the Free Software Foundation, either version 3 of the License, or     |
00017    |     (at your option) any later version.                                   |
00018    |                                                                           |
00019    |   MRPT is distributed in the hope that it will be useful,                 |
00020    |     but WITHOUT ANY WARRANTY; without even the implied warranty of        |
00021    |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         |
00022    |     GNU General Public License for more details.                          |
00023    |                                                                           |
00024    |     You should have received a copy of the GNU General Public License     |
00025    |     along with MRPT.  If not, see <http://www.gnu.org/licenses/>.         |
00026    |                                                                           |
00027    +---------------------------------------------------------------------------+ */
00028 #ifndef UTILSDEFS_H
00029 #define UTILSDEFS_H
00030 
00031 // This header will be included in ALL mrpt programs.
00032 
00033 /* ------------------------------------
00034           Disable some warnings
00035    ------------------------------------ */
00036 #if defined(_MSC_VER)
00037         #pragma warning(disable:4786) // (Compiler: Visual C++) Disable warning for too long debug names:
00038         #pragma warning(disable:4702) // (Compiler: Visual C++) Disable warning for unreachable code (I don't know why some of these errors appear in the STANDARD LIBRARY headers with Visual Studio 2003!):
00039         #pragma warning(disable:4244) // (Compiler: Visual C++) Conversion double->float
00040         #pragma warning(disable:4305)
00041         #pragma warning(disable:4267)
00042         #pragma warning(disable:4290) // Visual C++ does not implement decl. specifiers: throw(A,B,...)
00043         #pragma warning(disable:4251) // Visual C++ 2003+ warnings on STL classes when exporting to DLL...
00044         #pragma warning(disable:4275)
00045         #if (_MSC_VER >= 1400 )
00046                 // MS believes they have the right to deprecate functions in the C++ Standard STL... disable their warnings:
00047                 #define _SCL_SECURE_NO_WARNINGS
00048                 #pragma warning(disable:4996)
00049                 // For the new secure library in VC++8
00050                 #if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
00051                         #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
00052                 #endif
00053         #endif
00054 #endif
00055 
00056 #if defined(__BORLANDC__)
00057         #pragma warn -8027      // (Compiler: Borland C++) Disable a warning for inline functions
00058         #pragma warn -8012      // (Compiler: Borland C++) Disable a warning for override of virtual functions, while in reality there are many virtual function with different parameters
00059         #pragma warn -8022
00060 #endif
00061 
00062 #include <mrpt/config.h>
00063 #include <mrpt/system/os.h>
00064 
00065 // If we are building a DLL, do not link against the .lib files:
00066 #if defined(MRPT_BUILT_AS_DLL) && defined(mrpt_core_EXPORTS)
00067 #       define MRPT_SKIP_AUTOINCLUDE_LIBS
00068 #endif
00069 
00070 #define _IAMINUTILSDEFS_H
00071 #include <mrpt/utils/utils_impexp.h>  // DLL import/export definitions
00072 #undef _IAMINUTILSDEFS_H
00073 
00074 // Use a few lines from boost here
00075 //  (C) Copyright John Maddock 2001 - 2003.
00076 //  (C) Copyright Darin Adler 2001.
00077 //  (C) Copyright Peter Dimov 2001.
00078 //  (C) Copyright Bill Kempf 2002.
00079 //  (C) Copyright Jens Maurer 2002.
00080 //  (C) Copyright David Abrahams 2002 - 2003.
00081 //  (C) Copyright Gennaro Prota 2003.
00082 //  (C) Copyright Eric Friedman 2003.
00083 // License: Boost Software License   See LICENSE.txt for the full license.
00084 #ifndef BOOST_JOIN
00085 #define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
00086 #define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
00087 #define BOOST_DO_JOIN2( X, Y ) X##Y
00088 #endif
00089 
00090 /* ------------------------------------------------
00091     Automatically tell the linker to include
00092          the correct MRPT ".lib" file into the
00093          user's application.
00094    ----------------------------------------------- */
00095 // Borland C++
00096 #if (defined(_MSC_VER) || defined(__BORLANDC__)) && !defined(MRPT_SKIP_AUTOINCLUDE_LIBS)
00097 #       if defined(_DEBUG)
00098 #               pragma comment (lib, BOOST_JOIN( BOOST_JOIN("libmrpt-core",MRPT_VERSION_POSTFIX),"-dbg.lib"))
00099 #               if !defined(MRPT_BUILT_AS_DLL)  // If built as DLL, user apps only need to link against mrpt-core
00100 #                       if MRPT_HAS_SIFT_HESS && MRPT_HAS_OPENCV
00101 #                               pragma comment (lib, BOOST_JOIN( BOOST_JOIN("libmrpt-sift-hess",MRPT_VERSION_POSTFIX),"-dbg.lib"))
00102 #                       endif
00103 #                       if !MRPT_HAS_WXWIDGETS && MRPT_HAS_ZLIB && !MRPT_HAS_ZLIB_SYSTEM
00104 #                               pragma comment (lib, BOOST_JOIN( BOOST_JOIN("libmrpt-zlib",MRPT_VERSION_POSTFIX),"-dbg.lib"))
00105 #                       endif
00106 #               endif
00107 #       else
00108 #               pragma comment (lib, BOOST_JOIN( BOOST_JOIN("libmrpt-core",MRPT_VERSION_POSTFIX),".lib"))
00109 #               if !defined(MRPT_BUILT_AS_DLL)  // If built as DLL, user apps only need to link against mrpt-core
00110 #                       if MRPT_HAS_SIFT_HESS && MRPT_HAS_OPENCV
00111 #                               pragma comment (lib, BOOST_JOIN( BOOST_JOIN("libmrpt-sift-hess",MRPT_VERSION_POSTFIX),".lib"))
00112 #                       endif
00113 #                       if !MRPT_HAS_WXWIDGETS && MRPT_HAS_ZLIB && !MRPT_HAS_ZLIB_SYSTEM
00114 #                               pragma comment (lib, BOOST_JOIN( BOOST_JOIN("libmrpt-zlib",MRPT_VERSION_POSTFIX),".lib"))
00115 #                       endif
00116 #               endif
00117 #       endif
00118 #endif
00119 
00120 
00121 // A cross-compiler definition for "deprecated"-warnings
00122 #if defined(__GNUC__) && (__GNUC__ - 0 > 3 || (__GNUC__ - 0 == 3 && __GNUC_MINOR__ - 0 >= 2))
00123    /* gcc >= 3.2 */
00124 #   define MRPT_DEPRECATED_PRE(_MSG)
00125         // The "message" is not supported yet in GCC (JL: wait for gcc 4.4??)
00126         //#   define MRPT_DEPRECATED_POST(_MSG) __attribute__ ((deprecated(_MSG)))
00127 #   define MRPT_DEPRECATED_POST(_MSG) __attribute__ ((deprecated))
00128 # elif defined(_MSC_VER) && (_MSC_VER >= 1300)
00129   /* msvc >= 7 */
00130 #   define MRPT_DEPRECATED_PRE(_MSG)  __declspec(deprecated (_MSG))
00131 #   define MRPT_DEPRECATED_POST(_MSG)
00132 # else
00133 #  define MRPT_DEPRECATED_PRE(_MSG)
00134 #  define MRPT_DEPRECATED_POST(_MSG)
00135 # endif
00136 
00137 /** Usage: MRPT_DECLARE_DEPRECATED_FUNCTION("Use XX instead", void myFunc(double)); */
00138 #define MRPT_DECLARE_DEPRECATED_FUNCTION(__MSG, __FUNC) MRPT_DEPRECATED_PRE(__MSG) __FUNC MRPT_DEPRECATED_POST(__MSG)
00139 
00140 /** Declare MRPT_TODO(message)  */
00141 #if defined(_MSC_VER)
00142         #define MRPT_DO_PRAGMA(x) __pragma(x)
00143 #elif defined(__GNUC__)
00144         #define MRPT_DO_PRAGMA(x) _Pragma (#x)
00145 #else
00146         #define MRPT_DO_PRAGMA(x)
00147 #endif
00148 
00149 #define MRPT_TODO(x) MRPT_DO_PRAGMA(message ("TODO: " #x))
00150 
00151 // Define a decl. modifier for printf-like format checks at compile time:
00152 #ifdef __GNUC__
00153 #       define MRPT_printf_format_check(_FMT_,_VARARGS_)  __attribute__ ((__format__ (__printf__, _FMT_,_VARARGS_)))
00154 #else
00155 #       define MRPT_printf_format_check(_FMT_,_VARARGS_)
00156 #endif
00157 // Define a decl. modifier for scanf-like format checks at compile time:
00158 #ifdef __GNUC__
00159 #       define MRPT_scanf_format_check(_FMT_,_VARARGS_)  __attribute__ ((__format__ (__scanf__, _FMT_,_VARARGS_)))
00160 #else
00161 #       define MRPT_scanf_format_check(_FMT_,_VARARGS_)
00162 #endif
00163 
00164 /** Used after member declarations */
00165 #define MRPT_NO_THROWS          throw()
00166 
00167 
00168 // A cross-compiler definition for aligned memory structures:
00169 #if defined(_MSC_VER)
00170         #define MRPT_ALIGN16 __declspec(align(16))
00171         #define MRPT_ALIGN32 __declspec(align(32))
00172 #elif defined(__GNUC__)
00173         #define MRPT_ALIGN16 __attribute__((aligned(16)))
00174         #define MRPT_ALIGN32 __attribute__((aligned(32)))
00175 #else
00176         #define MRPT_ALIGN16
00177         #define MRPT_ALIGN32
00178 #endif
00179 
00180 // Enable leak memory debugging:
00181 #if defined(_DEBUG) && defined(_MSC_VER) && (_MSC_VER>=1400)
00182         #define _CRTDBG_MAP_ALLOC
00183         #include <stdlib.h>
00184         #include <crtdbg.h>
00185 #endif
00186 
00187 // Utils C++ headers:
00188 #include <cstddef>
00189 #include <stdlib.h>
00190 #include <cstdlib>
00191 #include <cmath>
00192 
00193 #if HAVE_ALLOCA_H
00194 #include <alloca.h>
00195 #endif
00196 
00197 // C++ STD Library:
00198 #include <vector>
00199 #include <set>
00200 #include <algorithm>
00201 #include <iterator>
00202 #include <iostream>
00203 #include <iomanip>
00204 #include <fstream>
00205 #include <cstring>
00206 #include <exception>
00207 #include <stdexcept>
00208 #include <limits>
00209 #include <sstream>
00210 
00211 // STL+ library:
00212 #include <mrpt/otherlibs/stlplus/smart_ptr.hpp>
00213 
00214 // Standard elemental types:
00215 #include <mrpt/utils/types.h>
00216 
00217 /** This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
00218  */
00219 namespace mrpt
00220 {
00221         /** A std::string version of C sprintf.
00222           *  You can call this to obtain a std::string using printf-like syntax.
00223           *  Based on very nice code by Paul Senzee, published at http://senzee.blogspot.com/2006/05/c-formatting-stdstring.html
00224           *  Function implemented in format.cpp
00225           */
00226         std::string MRPTDLLIMPEXP format(const char *fmt, ...) MRPT_printf_format_check(1,2);
00227 
00228         namespace utils
00229         {
00230                 class CFileStream;
00231                 void MRPTDLLIMPEXP global_profiler_enter(const char *func_name) MRPT_NO_THROWS;
00232                 void MRPTDLLIMPEXP global_profiler_leave(const char *func_name) MRPT_NO_THROWS;
00233 
00234                 struct CProfilerProxy {
00235                         const char*f;
00236                         CProfilerProxy(const char*func_name) : f(func_name) { global_profiler_enter(f); }
00237                         ~CProfilerProxy() { global_profiler_leave(f); }
00238                 };
00239         }
00240         namespace system
00241         {
00242                 // Forward definition: (Required for Visual C++ 6 implementation of THROW_EXCEPTION...)
00243                 std::string  MRPTDLLIMPEXP extractFileName(const std::string &filePath);
00244                 std::string MRPTDLLIMPEXP stack_trace(bool calling_from_exception);
00245         }
00246 
00247         namespace math
00248         {
00249             bool MRPTDLLIMPEXP isNaN(float v) MRPT_NO_THROWS;
00250             bool MRPTDLLIMPEXP isNaN(double v) MRPT_NO_THROWS;
00251             bool MRPTDLLIMPEXP isFinite(float v) MRPT_NO_THROWS;
00252             bool MRPTDLLIMPEXP isFinite(double v) MRPT_NO_THROWS;
00253         }
00254 } // End of namespace
00255 
00256 
00257 /** A macro for obtaining the name of the current function:
00258   */
00259 #if defined(__BORLANDC__)
00260                 #define __CURRENT_FUNCTION_NAME__       __FUNC__
00261 #elif defined(_MSC_VER) && (_MSC_VER>=1300)
00262                 #define __CURRENT_FUNCTION_NAME__       __FUNCTION__
00263 #elif defined(_MSC_VER) && (_MSC_VER<1300)
00264                 // Visual C++ 6 HAS NOT A __FUNCTION__ equivalent.
00265 #define __CURRENT_FUNCTION_NAME__       ::system::extractFileName(__FILE__).c_str()
00266 #else
00267                 #define __CURRENT_FUNCTION_NAME__       __PRETTY_FUNCTION__
00268 #endif
00269 
00270 
00271 /** \def THROW_EXCEPTION(msg)
00272  * \param msg This can be a char*, a std::string, or a literal string.
00273  * Defines a unified way of reporting exceptions
00274  * \sa MRPT_TRY_START, MRPT_TRY_END, THROW_EXCEPTION_CUSTOM_MSG1
00275  */
00276 #define THROW_EXCEPTION(msg)    \
00277         {\
00278                 std::ostringstream auxCompStr;\
00279                 auxCompStr << "\n\n =============== MRPT EXCEPTION =============\n";\
00280                 auxCompStr << __CURRENT_FUNCTION_NAME__ << ", line " << __LINE__ << ":\n";\
00281                 auxCompStr << msg << std::endl; \
00282                 auxCompStr << mrpt::system::stack_trace(); \
00283                 throw std::logic_error( auxCompStr.str() );\
00284         }\
00285 
00286 /** \def THROW_EXCEPTION_CUSTOM_MSG1
00287   * \param e The caught exception.
00288   *     \param msg Is a char* or literal string.
00289   */
00290 #define THROW_EXCEPTION_CUSTOM_MSG1(msg,param1) \
00291         {\
00292                 std::ostringstream auxCompStr;\
00293                 auxCompStr << "\n\n =============== MRPT EXCEPTION =============\n";\
00294                 auxCompStr << __CURRENT_FUNCTION_NAME__ << ", line " << __LINE__ << ":\n";\
00295                 auxCompStr << mrpt::format(msg,param1)<< std::endl; \
00296                 auxCompStr << mrpt::system::stack_trace(); \
00297                 throw std::logic_error( auxCompStr.str() );\
00298         }\
00299 
00300 
00301 /** \def THROW_TYPED_EXCEPTION(msg,exceptionClass)
00302  * Defines a unified way of reporting exceptions of type different from "std::exception"
00303  * \sa MRPT_TRY_START, MRPT_TRY_END
00304  */
00305 #define THROW_TYPED_EXCEPTION(msg,exceptionClass)       \
00306         {\
00307                 std::ostringstream auxCompStr;\
00308                 auxCompStr << "\n\n =============== MRPT EXCEPTION =============\n";\
00309                 auxCompStr << __CURRENT_FUNCTION_NAME__ << ", line " << __LINE__ << ":\n";\
00310                 auxCompStr << msg << std::endl; \
00311                 auxCompStr << mrpt::system::stack_trace(); \
00312                 throw exceptionClass( auxCompStr.str() );\
00313         }\
00314 
00315 /** \def THROW_EXCEPTION_CUSTOM_MSG1
00316   * \param e The caught exception.
00317   *     \param msg Is a char* or literal string.
00318   */
00319 #define THROW_TYPED_EXCEPTION_CUSTOM_MSG1(msg,param1,exceptionClass)    \
00320         {\
00321                 std::ostringstream auxCompStr;\
00322                 auxCompStr << "\n\n =============== MRPT EXCEPTION =============\n";\
00323                 auxCompStr << __CURRENT_FUNCTION_NAME__ << ", line " << __LINE__ << ":\n";\
00324                 auxCompStr << mrpt::format(msg,param1)<< std::endl; \
00325                 auxCompStr << mrpt::system::stack_trace(); \
00326                 throw exceptionClass( auxCompStr.str() );\
00327         }\
00328 
00329 
00330 /** \def THROW_STACKED_EXCEPTION
00331  * \sa MRPT_TRY_START, MRPT_TRY_END
00332  */
00333 #define THROW_STACKED_EXCEPTION(e)      \
00334         {\
00335                 std::string str( e.what() );\
00336                 if (str.find("MRPT stack trace")==std::string::npos) \
00337                 { \
00338                         str+= __CURRENT_FUNCTION_NAME__;\
00339                         str+= mrpt::format(", line %i:\n", __LINE__ );\
00340                         if (str.size()>3000) { std::cerr << "TOO MANY STACKED EXCEPTIONS!: " << std::endl << str << std::endl; abort(); } \
00341                         throw std::logic_error( str );\
00342                 } \
00343                 else throw std::logic_error( e.what() );\
00344         }\
00345 
00346 /** \def THROW_STACKED_EXCEPTION_CUSTOM_MSG
00347   * \param e The caught exception.
00348   *     \param msg Is a char* or std::string.
00349   */
00350 #define THROW_STACKED_EXCEPTION_CUSTOM_MSG1(e,msg)      \
00351         {\
00352                 std::ostringstream auxCompStr;\
00353                 auxCompStr << e.what() ;  \
00354                 auxCompStr << msg << std::endl; \
00355                 throw std::logic_error( auxCompStr.str() );\
00356         }\
00357 
00358 /** \def THROW_STACKED_EXCEPTION_CUSTOM_MSG
00359   * \param e The caught exception.
00360   *     \param stuff Is a printf-like sequence of params, e.g: "The error happens for x=%i",x
00361   */
00362 #define THROW_STACKED_EXCEPTION_CUSTOM_MSG2(e,stuff,param1)     \
00363         {\
00364                 std::ostringstream auxCompStr;\
00365                 auxCompStr << e.what() ;  \
00366                 auxCompStr << mrpt::format( stuff, param1 ) << std::endl; \
00367                 throw std::logic_error( auxCompStr.str() );\
00368         }\
00369 
00370 /** For use in CSerializable implementations */
00371 #define MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(V) THROW_EXCEPTION(mrpt::format("Cannot parse object: unknown serialization version number: '%i'",static_cast<int>(version)))
00372 
00373 
00374 #if MRPT_HAS_ASSERT
00375         /** Defines an assertion mechanism.
00376          * \note Do NOT put code that must be always executed inside this statement, but just comparisons. This is because users might require ASSERT_'s to be ignored for optimized releases.
00377          * \sa MRPT_TRY_START, MRPT_TRY_END
00378          */
00379 #       define ASSERTMSG_(f,__ERROR_MSG) \
00380         { \
00381         if (!(f)) THROW_EXCEPTION( ::std::string( __ERROR_MSG ) ); \
00382         }
00383 
00384         /** Defines an assertion mechanism.
00385          * \note Do NOT put code that must be always executed inside this statement, but just comparisons. This is because users might require ASSERT_'s to be ignored for optimized releases.
00386          * \sa MRPT_TRY_START, MRPT_TRY_END
00387          */
00388 #       define ASSERT_(f) \
00389                 ASSERTMSG_(f, "Assert condition failed: " + ::std::string(#f) )
00390 
00391 /** Throws an exception if the number is NaN, IND, or +/-INF, or return the same number otherwise.
00392   */
00393 #define MRPT_CHECK_NORMAL_NUMBER(v) \
00394         { \
00395                 if (math::isNaN(v)) THROW_EXCEPTION("Check failed (value is NaN)"); \
00396                 if (!math::isFinite(v)) THROW_EXCEPTION("Check failed (value is not finite)"); \
00397         }
00398 
00399         // The following macro is based on dclib:
00400         // Copyright (C) 2003  Davis E. King (davisking@users.sourceforge.net)
00401         // License: Boost Software License   See LICENSE.txt for the full license.
00402         namespace mrpt
00403         {
00404                 namespace utils
00405                 {
00406                         template <bool value> struct compile_time_assert;
00407                         template <> struct compile_time_assert<true> { enum {value=1};  };
00408                 }
00409         }
00410         #define MRPT_COMPILE_TIME_ASSERT(expression) \
00411                         typedef char BOOST_JOIN(MRPT_CTA, __LINE__)[::mrpt::utils::compile_time_assert<(bool)(expression)>::value];
00412 
00413 #else
00414 #       define ASSERTMSG_(f,__ERROR_MSG)  { }
00415 #       define ASSERT_(f) { }
00416 #       define MRPT_CHECK_NORMAL_NUMBER(val) { }
00417 #       define MRPT_COMPILE_TIME_ASSERT(f) { }
00418 #endif
00419 
00420 /** Defines an assertion mechanism - only when compiled in debug.
00421  * \note Do NOT put code that must be always executed inside this statement, but just comparisons. This is because users might require ASSERT_'s to be ignored for optimized releases.
00422  * \sa MRPT_TRY_START, MRPT_TRY_END
00423  */
00424 #ifdef _DEBUG
00425 #       define ASSERTDEB_(f) ASSERT_(f)
00426 #else
00427 #       define ASSERTDEB_(f) { }
00428 #endif
00429 
00430 
00431 
00432 /** Can be used to avoid "not used parameters" warnings from the compiler
00433  */
00434 #define MRPT_UNUSED_PARAM(a)            (void)(a)
00435 
00436 #if MRPT_HAS_STACKED_EXCEPTIONS
00437         /** The start of a standard MRPT "try...catch()" block that allows tracing throw the call stack after an exception.
00438           * \sa MRPT_TRY_END,MRPT_TRY_END_WITH_CLEAN_UP
00439           */
00440 #       define MRPT_TRY_START   \
00441         try { \
00442 
00443         /** The end of a standard MRPT "try...catch()" block that allows tracing throw the call stack after an exception.
00444           * \sa MRPT_TRY_START,MRPT_TRY_END_WITH_CLEAN_UP
00445           */
00446 #       define MRPT_TRY_END     \
00447         } \
00448         catch (std::bad_alloc &e) \
00449         { \
00450                 std::cerr << "MRPT CRITICAL ERROR: Out of memory:\n" << e.what() << std::endl; \
00451                 exit(-1); throw std::runtime_error("dummy"); \
00452         } \
00453         catch (std::exception &e) \
00454         { \
00455                 THROW_STACKED_EXCEPTION(e); \
00456         } \
00457         catch (...) \
00458         { \
00459                 THROW_EXCEPTION("Unexpected runtime error!"); \
00460         } \
00461 
00462         /** The end of a standard MRPT "try...catch()" block that allows tracing throw the call stack after an exception, including a "clean up" piece of code to be run before throwing the exceptions.
00463           * \sa MRPT_TRY_END,MRPT_TRY_START
00464           */
00465 #       define MRPT_TRY_END_WITH_CLEAN_UP(stuff)        \
00466         } \
00467         catch (std::bad_alloc &e) \
00468         { \
00469                 std::cerr << "MRPT CRITICAL ERROR: Out of memory:\n" << e.what() << std::endl; \
00470                 exit(-1); throw std::runtime_error("dummy"); \
00471         } \
00472         catch (std::exception &e) \
00473         { \
00474                 {stuff} \
00475                 THROW_STACKED_EXCEPTION(e); \
00476         } \
00477         catch (...) \
00478         { \
00479                 { stuff } \
00480                 THROW_EXCEPTION("Unexpected runtime error!"); \
00481         } \
00482 
00483 #else
00484 #       define MRPT_TRY_START
00485 #       define MRPT_TRY_END
00486 #       define MRPT_TRY_END_WITH_CLEAN_UP(stuff)
00487 #endif
00488 
00489 #if MRPT_ENABLE_EMBEDDED_GLOBAL_PROFILER
00490 #       define  MRPT_PROFILE_FUNC_START  ::mrpt::utils::CProfilerProxy BOOST_JOIN(__dum_var,__LINE__)( __CURRENT_FUNCTION_NAME__);
00491 #else
00492 #       define  MRPT_PROFILE_FUNC_START
00493 #endif
00494 
00495 // General macros for use within each MRPT method/function. They provide:
00496 //  - Nested exception handling
00497 //  - Automatic profiling stats (in Debug only)
00498 // ---------------------------------------------------------
00499 #define MRPT_START  \
00500         MRPT_PROFILE_FUNC_START \
00501         MRPT_TRY_START
00502 
00503 #define MRPT_END  \
00504         MRPT_TRY_END
00505 
00506 #define MRPT_END_WITH_CLEAN_UP(stuff) \
00507         MRPT_TRY_END_WITH_CLEAN_UP(stuff)
00508 
00509 // Generic constants and defines:
00510 // ---------------------------------------------------------
00511 
00512 #ifndef M_PI
00513 /** The PI constant
00514  */
00515         #define M_PI 3.14159265358979323846264338327950288
00516 #endif
00517 
00518 #ifndef M_2PI
00519 /** The 2*PI constant
00520  */
00521         #define M_2PI 6.283185307179586476925286766559
00522 #endif
00523 
00524 #define M_PIf  3.14159265358979f
00525 #define M_2PIf 6.28318530717959f
00526 
00527 
00528 // Avoid conflicting declaration of max macro in windows headers
00529 #if defined(MRPT_OS_WINDOWS) && !defined(NOMINMAX)
00530 #       define NOMINMAX
00531 #       ifdef max
00532 #               undef   max
00533 #               undef   min
00534 #       endif
00535 #endif
00536 
00537 //  We want to avoid defining "max" & "min" as #define's since it create conflicts
00538 //    with methods, variables, etc... with the same name in some compilers.
00539 // Use std::max & std::min for all compilers by default, but for MSVC6 it does not exist:
00540 #if defined(_MSC_VER) && (_MSC_VER<1300)
00541 #       ifndef max
00542                 namespace std
00543                 {
00544                         template<class T> inline const T max(const T& A,const T& B) { return A>B ? A:B; }
00545                         template<class T> inline const T min(const T& A,const T& B) { return A<B ? A:B; }
00546                 }
00547 #       else
00548 #               define  MAX3_MSVC6_VERSION
00549 #       endif
00550 #endif
00551 
00552 // Min & Max:
00553 #ifndef MAX3_MSVC6_VERSION
00554         template<typename T> inline const T  min3(const T& A, const T& B,const T& C) { return std::min<T>(A, std::min<T>(B,C) ); }
00555         template<typename T> inline const T  max3(const T& A, const T& B,const T& C) { return std::max<T>(A, std::max<T>(B,C) ); }
00556 #else
00557 #       define max3(A,B,C) max(A,max(B,C))
00558 #       define min3(A,B,C) min(A,min(B,C))
00559 #endif
00560 
00561 namespace mrpt
00562 {
00563         namespace math
00564         {
00565                 // This inline function is used everywhere, so just move it here even it's not a forward declaration!
00566                 /*! Returns the size of the matrix in the i'th dimension: 1=rows, 2=columns (MATLAB-compatible function)
00567                   *  \note Template argument MATRIXLIKE can be: CMatrixTemplate, CMatrixTemplateNumeric, CMatrixFixedNumeric
00568                   */
00569                 template <class MATRIXLIKE>
00570                 inline size_t size( const MATRIXLIKE& m, int dim )
00571                 {
00572                         if (dim==1)
00573                                 return m.getRowCount();
00574                         else if (dim==2)
00575                                 return m.getColCount();
00576                         else THROW_EXCEPTION_CUSTOM_MSG1("size: Queried matrix dimension must be 1 or 2. Called with i=%i",dim);
00577                 }
00578         }
00579 
00580 
00581         namespace utils
00582         {
00583                 /** Degrees to radians */
00584                 inline double DEG2RAD(const double x) { return x*M_PI/180.0;    }
00585 
00586                 /** Degrees to radians */
00587                 inline float DEG2RAD(const float x) { return x*M_PIf/180.0f; }
00588 
00589                 /** Degrees to radians */
00590                 inline float DEG2RAD(const int x) { return x*M_PIf/180.0f; }
00591 
00592                 /** Radians to degrees */
00593                 inline double RAD2DEG(const double x) { return x*180.0/M_PI; }
00594 
00595                 /** Radians to degrees */
00596                 inline float RAD2DEG(const float x) { return x*180.0f/M_PIf; }
00597 
00598                 /** Returns the sign of X as "1" or "-1" */
00599                 template <typename T>
00600                 inline int sign(T x) { return x<0 ? -1:1; }
00601 
00602                 /** Returns the sign of X as "0", "1" or "-1" */
00603                 template <typename T>
00604                 inline int signWithZero(T x)    { return x==0?0:sign(x);}
00605 
00606                 /** Returns the closer integer (int) to x */
00607                 template <typename T>
00608                 inline int round(const T value)
00609                 {
00610                 #if MRPT_HAS_SSE2
00611                         __m128d t = _mm_set_sd( value );
00612                         return _mm_cvtsd_si32(t);
00613                 #elif (defined WIN32 || defined _WIN32) && !defined WIN64 && !defined _WIN64 && defined _MSC_VER
00614                         int t;
00615                         __asm
00616                         {
00617                                 fld value;
00618                                 fistp t;
00619                         }
00620                         return t;
00621                 #elif defined HAVE_LRINT || defined __GNUC__
00622                         return static_cast<int>(lrint(value));
00623                 #else
00624                         return static_cast<int>(value + 0.5);
00625                 #endif
00626                 }
00627 
00628                 /** Returns the closer integer (long) to x */
00629                 template <typename T>
00630                 inline long round_long(const T value)
00631                 {
00632                 #if MRPT_HAS_SSE2 && MRPT_WORD_SIZE==64
00633                         __m128d t = _mm_set_sd( value );
00634                         return _mm_cvtsd_si64(t);
00635                 #elif (defined WIN32 || defined _WIN32) && !defined WIN64 && !defined _WIN64 && defined _MSC_VER
00636                         long t;
00637                         __asm
00638                         {
00639                                 fld value;
00640                                 fistp t;
00641                         }
00642                         return t;
00643                 #elif defined HAVE_LRINT || defined __GNUC__
00644                         return lrint(value);
00645                 #else
00646                         return static_cast<long>(value + 0.5);
00647                 #endif
00648                 }
00649 
00650                 /** Rounds toward zero  */
00651                 template <typename T>
00652                 inline int fix(T x) { return  x>0 ? static_cast<int>(floor(static_cast<double>(x))) : static_cast<int>(ceil(static_cast<double>(x))) ; }
00653 
00654                 /** Inline function for the square of a number. */
00655                 template<class T>
00656                 inline T square(const T& x)    { return x*x; }
00657 
00658 
00659                 /** Utility to get a cast'ed pointer from a smart pointer */
00660                 template <class R, class P>
00661                 inline R* getAs(stlplus::smart_ptr_clone<P> &o) { return static_cast<R*>( & (*o) ); }
00662 
00663                 /** Utility to get a cast'ed pointer from a smart pointer */
00664                 template <class R, class P>
00665                 inline const R* getAs(const stlplus::smart_ptr_clone<P> &o) { return static_cast<const R*>( & (*o) ); }
00666 
00667 
00668                 /** Reverse the order of the bytes of a given type (useful for transforming btw little/big endian)  */
00669                 template <class T> void reverseBytes(const T &v_in, T& v_out)
00670                 {
00671                         v_out = v_in;
00672                         uint8_t *ptr = reinterpret_cast<uint8_t*>(&v_out);
00673                         std::reverse(ptr,ptr+sizeof(T));
00674                 }
00675 
00676                 /** If the second argument is below the first one, set the first argument to this lower value. */
00677                 template <typename T,typename K>
00678                 inline void keep_min(T &var,  const K test_val) {
00679                         if (test_val<var) var = test_val;
00680                 }
00681 
00682                 /** If the second argument is above the first one, set the first argument to this higher value. */
00683                 template <typename T,typename K>
00684                 inline void keep_max(T &var,  const K test_val) {
00685                         if (test_val>var) var = test_val;
00686                 }
00687 
00688                 /** Calls "delete" to free an object only if the pointer is not NULL, then set the pointer to NULL. */
00689                 template <class T>
00690                 void delete_safe(T *& ptr) {
00691                         if (ptr) {
00692                                 delete ptr;
00693                                 ptr = NULL;
00694                         }
00695                 }
00696 
00697         } // End of namespace
00698 } // end of namespace
00699 #endif