nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_COMMON_H
+00027 #define NL_COMMON_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 
+00031 #include <ctype.h>
+00032 #include <stdio.h>
+00033 #include <stdarg.h>
+00034 #include <stdlib.h>
+00035 #include <math.h>
+00036 #include <algorithm>
+00037 #include <string>
+00038 #include <vector>
+00039 #include <sstream>
+00040 
+00041 #ifdef NL_OS_WINDOWS
+00042 #       include <process.h>
+00043 #else
+00044 #       include <math.h>
+00045 #       include <unistd.h>
+00046 #       include <sys/types.h>
+00047 #endif
+00048 
+00050 namespace       NLMISC
+00051 {
+00052 
+00053 // Windows posix function remapping
+00054 #ifdef NL_OS_WINDOWS
+00055 #define vsnprintf _vsnprintf
+00056 #endif // NL_OS_WINDOWS
+00057 
+00058 
+00059 
+00066 const int MaxCStringSize = 1024*2;
+00067 
+00068 
+00071 const double Pi = 3.1415926535897932384626433832795;
+00072 
+00073 
+00094 #define NLMISC_CONVERT_VARGS(_dest,_format,_size) \
+00095 char _cstring[_size]; \
+00096 va_list _args; \
+00097 va_start (_args, _format); \
+00098 int _res = vsnprintf (_cstring, _size-1, _format, _args); \
+00099 if (_res == -1 || _res == _size-1) \
+00100 { \
+00101         _cstring[_size-1] = '\0'; \
+00102 } \
+00103 va_end (_args); \
+00104 _dest = _cstring
+00105 
+00106 
+00107 
+00115 sint smprintf( char *buffer, size_t count, const char *format, ... );
+00116 
+00117 
+00120 inline float frand(float mod)
+00121 {
+00122         double  r = (double) rand();
+00123         r/= (double) RAND_MAX;
+00124         return (float)(r * mod);
+00125 }
+00126 
+00127 
+00130 inline sint fsgn(double f)
+00131 {
+00132         if(f<0)
+00133                 return -1;
+00134         else if(f>0)
+00135                 return 1;
+00136         else
+00137                 return 0;
+00138 }
+00139 
+00140 
+00143 template<class T>       inline T sqr(const T &v)
+00144 {
+00145         return v * v;
+00146 }
+00147 
+00148 
+00151 template<class T, class U, class V>     inline void clamp(T &v, const U &min, const V &max)
+00152 {
+00153         v = (v < min) ? min : v;
+00154         v = (v > max) ? max : v;
+00155 }
+00156 
+00157 
+00160 template<class T>       inline T minof(const T& a,  const T& b,  const T& c)
+00161         {return std::min(std::min(a,b),c);}
+00162 template<class T>       inline T minof(const T& a,  const T& b,  const T& c,  const T& d)
+00163         {return std::min(minof(a,b,c),d);}
+00164 template<class T>       inline T minof(const T& a,  const T& b,  const T& c,  const T& d,  const T& e)
+00165         {return std::min(minof(a,b,c,d),e);}
+00166 template<class T>       inline T maxof(const T& a,  const T& b,  const T& c)
+00167         {return std::max(std::max(a,b),c);}
+00168 template<class T>       inline T maxof(const T& a,  const T& b,  const T& c,  const T& d)
+00169         {return std::max(maxof(a,b,c),d);}
+00170 template<class T>       inline T maxof(const T& a,  const T& b,  const T& c,  const T& d,  const T& e)
+00171         {return std::max(maxof(a,b,c,d),e);}
+00172 
+00177 template<class T>       inline void contReset (T& a)
+00178 {
+00179         a.~T();
+00180 #undef new
+00181         new (&a) T;
+00182 #define new NL_NEW
+00183 }
+00184 
+00190 uint                    raiseToNextPowerOf2 (uint v);
+00191 
+00197 uint                    getPowerOf2 (uint v);
+00198 
+00201 bool                    isPowerOf2 (sint32 v);
+00202 
+00203 
+00206 inline float    degToRad( float deg )
+00207 {
+00208         return deg * (float)Pi / 180.0f;
+00209 }
+00210 
+00211 
+00214 inline float    radToDeg( float rad )
+00215 {
+00216         return rad * 180.0f / (float)Pi;
+00217 }
+00218 
+00219 
+00222 inline double   isValidDouble (double v)
+00223 {
+00224 #ifdef NL_OS_WINDOWS
+00225         return _finite(v) && !_isnan(v);
+00226 #else
+00227         return !isnan(v) && !isinf(v);
+00228 #endif
+00229 }
+00230 
+00231 
+00235 std::string             &strlwr ( std::string &str );
+00236 std::string             strlwr ( const std::string &str );
+00237 
+00241 char                    *strlwr ( char *str );
+00242 
+00246 std::string             &strupr ( std::string &str );
+00247 
+00251 char                    *strupr ( char *str );
+00252 
+00256 sint                    nlstricmp(const char *lhs, const char *rhs);
+00257 
+00260 sint                    nlstricmp(const std::string &lhs, const std::string &rhs);
+00261 
+00262 
+00263 
+00268 class Exception : public std::exception
+00269 {
+00270 protected:
+00271         std::string     _Reason;
+00272 public:
+00273         Exception();
+00274         Exception(const std::string &reason);
+00275         Exception(const char *format, ...);
+00276         virtual ~Exception() throw() {};
+00277         virtual const char      *what() const throw();
+00278 };
+00279 
+00280 
+00285 void nlSleep( uint32 ms );
+00286 
+00287 
+00289 #ifdef NL_OS_WINDOWS
+00290 #       define getpid _getpid
+00291 #endif
+00292 
+00294 uint getThreadId();
+00295 
+00297 std::string stringFromVector( const std::vector<uint8>& v, bool limited = true );
+00298 
+00299 
+00301 sint64 atoiInt64 (const char *ident, sint64 base = 10);
+00302 
+00304 void itoaInt64 (sint64 number, char *str, sint64 base = 10);
+00305 
+00306 
+00308 std::string bytesToHumanReadable (uint32 bytes);
+00309 
+00310 
+00313 bool launchProgram (const std::string &programName, const std::string &arguments);
+00314 
+00315 
+00316 
+00317 
+00318 
+00323 template<class T> std::string toString (const T &t)
+00324 {
+00325         std::stringstream ss;
+00326         ss << t;
+00327         return ss.str();
+00328 }
+00329 
+00330 
+00335 inline std::string toString (const char *format, ...)
+00336 {
+00337         std::string Result;
+00338         NLMISC_CONVERT_VARGS (Result, format, NLMISC::MaxCStringSize);
+00339         return Result;
+00340 }
+00341 
+00342 
+00343 /* All the code above is used to add our types (uint8, ...) in the stringstream (used by the toString() function).
+00344  * So we can use stringstream operator << and >> with all NeL simple types (except for ucchar and ucstring)
+00345  */
+00346 
+00347 #ifdef NL_OS_WINDOWS
+00348 
+00349 #if _MSC_VER < 1300     // visual or older (on visual .NET, we don't need to do that)
+00350 
+00351 #define NLMISC_ADD_BASIC_ISTREAM_OPERATOR(__type,__casttype) \
+00352 template <class _CharT, class _Traits> \
+00353 std::basic_istream<_CharT, _Traits>& __cdecl \
+00354 operator>>(std::basic_istream<_CharT, _Traits>& __is, __type& __z) \
+00355 { \
+00356         __casttype __z2 = (__casttype) __z; \
+00357         __is.operator>>(__z2); \
+00358         __z = (__type) __z2; \
+00359         return __is; \
+00360 } \
+00361  \
+00362 template <class _CharT, class _Traits> \
+00363 std::basic_ostream<_CharT, _Traits>& __cdecl \
+00364 operator<<(std::basic_ostream<_CharT, _Traits>& __os, const __type& __z) \
+00365 { \
+00366         std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __tmp; \
+00367         __tmp << (__casttype) __z; \
+00368         return __os << __tmp.str(); \
+00369 }
+00370 
+00371 NLMISC_ADD_BASIC_ISTREAM_OPERATOR(uint8, unsigned int);
+00372 NLMISC_ADD_BASIC_ISTREAM_OPERATOR(sint8, signed int);
+00373 NLMISC_ADD_BASIC_ISTREAM_OPERATOR(uint16, unsigned int);
+00374 NLMISC_ADD_BASIC_ISTREAM_OPERATOR(sint16, signed int);
+00375 NLMISC_ADD_BASIC_ISTREAM_OPERATOR(uint32, unsigned int);
+00376 NLMISC_ADD_BASIC_ISTREAM_OPERATOR(sint32, signed int);
+00377 
+00378 #endif // _MSC_VER < 1300
+00379 
+00380 
+00381 template <class _CharT, class _Traits>
+00382 std::basic_istream<_CharT, _Traits>& __cdecl
+00383 operator>>(std::basic_istream<_CharT, _Traits>& __is, uint64& __z)
+00384 {
+00385         __z = 0;
+00386         bool neg = false;
+00387         char c;
+00388         do
+00389         {
+00390                 __is >> c;
+00391         }
+00392         while (isspace(c));
+00393 
+00394         if (c == '-')
+00395         {
+00396                 neg = true;
+00397                 __is >> c;
+00398         }
+00399 
+00400         while (isdigit(c))
+00401         {
+00402                 __z *= 10;
+00403                 __z += c-'0';
+00404                 __is >> c;
+00405                 if (__is.fail())
+00406                         break;
+00407         }
+00408 
+00409         if (neg) __z = 0;
+00410 
+00411         return __is;
+00412 }
+00413 
+00414 template <class _CharT, class _Traits>
+00415 std::basic_ostream<_CharT, _Traits>& __cdecl
+00416 operator<<(std::basic_ostream<_CharT, _Traits>& __os, const uint64& __z)
+00417 {
+00418         std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __res;
+00419 
+00420         if (__z == 0)
+00421         {
+00422                 __res << '0';
+00423         }
+00424         else
+00425         {
+00426                 std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __tmp;
+00427                 uint64  __z2 = __z;
+00428                 while (__z2 != 0)
+00429                 {
+00430                         __tmp << (char)((__z2%10)+'0');
+00431                         __z2 /= 10;
+00432                 }
+00433 
+00434                 uint __s = __tmp.str().size();
+00435                 for (uint i = 0; i < __s; i++)
+00436                         __res << __tmp.str()[__s - 1 - i];
+00437         }
+00438         return __os << __res.str();
+00439 }
+00440 
+00441 template <class _CharT, class _Traits>
+00442 std::basic_istream<_CharT, _Traits>& __cdecl
+00443 operator>>(std::basic_istream<_CharT, _Traits>& __is, sint64& __z)
+00444 {
+00445         __z = 0;
+00446         bool neg = false;
+00447         char c;
+00448         do
+00449         {
+00450                 __is >> c;
+00451         }
+00452         while (isspace(c));
+00453 
+00454         if (c == '-')
+00455         {
+00456                 neg = true;
+00457                 __is >> c;
+00458         }
+00459 
+00460         while (isdigit(c))
+00461         {
+00462                 __z *= 10;
+00463                 __z += c-'0';
+00464                 __is >> c;
+00465                 if (__is.fail())
+00466                         break;
+00467         }
+00468 
+00469         if (neg) __z = -__z;
+00470 
+00471         return __is;
+00472 }
+00473 
+00474 template <class _CharT, class _Traits>
+00475 std::basic_ostream<_CharT, _Traits>& __cdecl
+00476 operator<<(std::basic_ostream<_CharT, _Traits>& __os, const sint64& __z)
+00477 {
+00478         std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __res;
+00479 
+00480         if (__z == 0)
+00481         {
+00482                 __res << '0';
+00483         }
+00484         else 
+00485         {
+00486                 sint64  __z2 = __z;
+00487 
+00488                 if (__z2 < 0)
+00489                 {
+00490                         __res << '-';
+00491                 }
+00492 
+00493                 std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __tmp;
+00494                 while (__z2 != 0)
+00495                 {
+00496                         if (__z2 < 0)
+00497                         {
+00498                                 __tmp << (char)((-(__z2%10))+'0');
+00499                         }
+00500                         else
+00501                         {
+00502                                 __tmp << (char)((__z2%10)+'0');
+00503                         }
+00504                         __z2 /= 10;
+00505                 }
+00506 
+00507                 uint __s = __tmp.str().size();
+00508                 for (uint i = 0; i < __s; i++)
+00509                         __res << __tmp.str()[__s - 1 - i];
+00510         }
+00511         return __os << __res.str();
+00512 }
+00513 
+00514 #endif // NL_OS_WINDOWS
+00515 
+00516 
+00517 
+00518 
+00519 }       // NLMISC
+00520 
+00521 #endif  // NL_COMMON_H
+
common.h
