common.h

Go to the documentation of this file.

/* Copyright, 2000 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_COMMON_H
#define NL_COMMON_H

#include "types_nl.h"

#include <cctype>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <cfloat>
#include <cstdarg>
#include <cstdlib>
#include <algorithm>

#ifdef NL_OS_WINDOWS
#   include <process.h>
#   include <intrin.h>
#else
#   include <cmath>
#   include <unistd.h>
#   include <sys/types.h>
#endif

#include "string_common.h"


namespace   NLMISC
{

#ifdef NL_CPU_INTEL

inline uint64 rdtsc()
{
    uint64 ticks;
#   ifdef NL_OS_WINDOWS
#   ifdef NL_NO_ASM
        ticks = uint64(__rdtsc());
#   else
        // We should use the intrinsic code now. ticks = uint64(__rdtsc());
        __asm   rdtsc
        __asm   mov     DWORD PTR [ticks], eax
        __asm   mov     DWORD PTR [ticks + 4], edx
#   endif // NL_NO_ASM
#   else
        __asm__ volatile(".byte 0x0f, 0x31" : "=a" (ticks.low), "=d" (ticks.high));
#   endif // NL_OS_WINDOWS
    return ticks;
}

#endif  // NL_CPU_INTEL


#define     breakable   \
    switch(1) case 1: default:


const double Pi = 3.1415926535897932384626433832795;


// retrieve size of a static array
#define sizeofarray(v) (sizeof(v) / sizeof((v)[0]))

inline float frand(float mod)
{
    double  r = (double) rand();
    r/= (double) RAND_MAX;
    return (float)(r * mod);
}


inline sint fsgn(double f)
{
    if(f<0)
        return -1;
    else if(f>0)
        return 1;
    else
        return 0;
}


template<class T>   inline T sqr(const T &v)
{
    return v * v;
}


template<class T, class U, class V> inline void clamp(T &v, const U &min, const V &max)
{
    v = (v < min) ? min : v;
    v = (v > max) ? max : v;
}


template<class T>   inline T minof(const T& a,  const T& b,  const T& c)
    {return std::min(std::min(a,b),c);}
template<class T>   inline T minof(const T& a,  const T& b,  const T& c,  const T& d)
    {return std::min(minof(a,b,c),d);}
template<class T>   inline T minof(const T& a,  const T& b,  const T& c,  const T& d,  const T& e)
    {return std::min(minof(a,b,c,d),e);}
template<class T>   inline T maxof(const T& a,  const T& b,  const T& c)
    {return std::max(std::max(a,b),c);}
template<class T>   inline T maxof(const T& a,  const T& b,  const T& c,  const T& d)
    {return std::max(maxof(a,b,c),d);}
template<class T>   inline T maxof(const T& a,  const T& b,  const T& c,  const T& d,  const T& e)
    {return std::max(maxof(a,b,c,d),e);}

template<class T>   inline void contReset (T& a)
{
    a.~T();
    new (&a) T;
}

uint            raiseToNextPowerOf2 (uint v);

uint            getPowerOf2 (uint v);

bool            isPowerOf2 (sint32 v);


inline float    degToRad( float deg )
{
    return deg * (float)Pi / 180.0f;
}


inline float    radToDeg( float rad )
{
    return rad * 180.0f / (float)Pi;
}


inline double   isValidDouble (double v)
{
#ifdef NL_OS_WINDOWS
    return _finite(v) && !_isnan(v);
#else
    return !std::isnan(v) && !std::isinf(v);
#endif
}


std::string toLower ( const std::string &str );
void        toLower ( char *str );
char        toLower ( const char ch );  // convert only one character

std::string toUpper ( const std::string &str);
void        toUpper ( char *str);

// Remove all the characters <= 32 (tab, space, new line, return, vertical tab etc..) at the beginning and at the end of a string
template <class T> T trim (const T &str)
{
    typename T::size_type start = 0;
    const typename T::size_type size = str.size();
    while (start < size && str[start] <= 32)
        start++;
    typename T::size_type end = size;
    while (end > start && str[end-1] <= 32)
        end--;
    return str.substr (start, end-start);
}

// remove spaces at the end of the string
template <class T> T trimRightWhiteSpaces (const T &str)
{
    typename T::size_type end = str.size();
    while (end > 0 && str[end-1] == ' ')
        end--;
    return str.substr (0, end);
}

// ****  DEPRECATED *****: PLEASE DON'T USE THESE METHODS BUT FUNCTIONS ABOVE toLower() and toUpper()
inline std::string      &strlwr ( std::string &str )        { str = toLower(str); return str; }
inline std::string       strlwr ( const std::string &str )  { return toLower(str); }
inline char         *strlwr ( char *str )               { toLower(str); return str; }
inline std::string      &strupr ( std::string &str )        { str = toUpper(str); return str; }
inline std::string       strupr ( const std::string &str )  { return toUpper(str); }
inline char         *strupr ( char *str )               { toUpper(str); return str; }


#ifndef NL_OS_WINDOWS
inline int stricmp(const char *lhs, const char *rhs) { return strcasecmp(lhs, rhs); }
inline int strnicmp(const char *lhs, const char *rhs, size_t n) { return strncasecmp(lhs, rhs, n); }
#endif

inline sint nlstricmp(const char *lhs, const char *rhs) { return stricmp(lhs, rhs); }
inline sint nlstricmp(const std::string &lhs, const std::string &rhs) { return stricmp(lhs.c_str(), rhs.c_str()); }
inline sint nlstricmp(const std::string &lhs, const char *rhs) { return stricmp(lhs.c_str(),rhs); }
inline sint nlstricmp(const char *lhs, const std::string &rhs) { return stricmp(lhs,rhs.c_str()); }

int     nlfseek64( FILE *stream, sint64 offset, int origin );

// Retrieve position in a file, same interface as ftell
sint64  nlftell64(FILE *stream);

class Exception : public std::exception
{
protected:
    std::string _Reason;
public:
    Exception();
    Exception(const std::string &reason);
    Exception(const char *format, ...);
    virtual ~Exception() throw() {}
    virtual const char  *what() const throw();
};


void nlSleep( uint32 ms );


#ifdef NL_OS_WINDOWS
#   define getpid _getpid
#endif

uint getThreadId();

std::string stringFromVector( const std::vector<uint8>& v, bool limited = true );


sint64 atoiInt64 (const char *ident, sint64 base = 10);

void itoaInt64 (sint64 number, char *str, sint64 base = 10);


std::string bytesToHumanReadable (const std::string &bytes);
std::string bytesToHumanReadable (uint64 bytes);

uint32 humanReadableToBytes (const std::string &str);

std::string secondsToHumanReadable (uint32 time);


uint32 fromHumanReadable (const std::string &str);


bool launchProgram (const std::string &programName, const std::string &arguments);

bool killProgram(uint32 pid);

bool abortProgram(uint32 pid);

/*acetemplate<class T> std::string toString (const T &t)
{
    std::stringstream ss;
    ss << t;
    return ss.str();
}
*/

/*#ifdef NL_OS_WINDOWS
inline std::string _toString (const char *format, ...)
#else
inline std::string toString (const char *format, ...)
#endif
{
    std::string Result;
    NLMISC_CONVERT_VARGS (Result, format, NLMISC::MaxCStringSize);
    return Result;
}

#ifdef NL_OS_WINDOWS
CHECK_TYPES(std::string toString, return _toString)
#endif // NL_OS_WINDOWS



#ifdef NL_OS_UNIX
inline std::string toString (const uint8 &t)
{
    std::stringstream ss;
    ss << (unsigned int)t;
    return ss.str();
}

inline std::string toString (const sint8 &t)
{
    std::stringstream ss;
    ss << (unsigned int)t;
    return ss.str();
}
#endif // NL_OS_UNIX
*/

template <class T> void explode (const T &src, const T &sep, std::vector<T> &res, bool skipEmpty = false)
{
    std::string::size_type oldpos = 0, pos;

    res.clear ();

    do
    {
        pos = src.find (sep, oldpos);
        T s;
        if(pos == std::string::npos)
            s = src.substr (oldpos);
        else
            s = src.substr (oldpos, (pos-oldpos));

        if (!skipEmpty || !s.empty())
            res.push_back (s);

        oldpos = pos+sep.size();
    }
    while(pos != std::string::npos);
}


/* All the code above is used to add our types (uint8, ...) in the stringstream (used by the toString() function).
 * So we can use stringstream operator << and >> with all NeL simple types (except for ucchar and ucstring)
 */
/*
#ifdef NL_OS_WINDOWS

#if _MSC_VER < 1300 // visual or older (on visual .NET, we don't need to do that)

#define NLMISC_ADD_BASIC_ISTREAM_OPERATOR(__type,__casttype) \
template <class _CharT, class _Traits> \
std::basic_istream<_CharT, _Traits>& __cdecl \
operator>>(std::basic_istream<_CharT, _Traits>& __is, __type& __z) \
{ \
    __casttype __z2 = (__casttype) __z; \
    __is.operator>>(__z2); \
    __z = (__type) __z2; \
    return __is; \
} \
 \
template <class _CharT, class _Traits> \
std::basic_ostream<_CharT, _Traits>& __cdecl \
operator<<(std::basic_ostream<_CharT, _Traits>& __os, const __type& __z) \
{ \
    std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __tmp; \
    __tmp << (__casttype) __z; \
    return __os << __tmp.str(); \
}

NLMISC_ADD_BASIC_ISTREAM_OPERATOR(uint8, unsigned int);
NLMISC_ADD_BASIC_ISTREAM_OPERATOR(sint8, signed int);
NLMISC_ADD_BASIC_ISTREAM_OPERATOR(uint16, unsigned int);
NLMISC_ADD_BASIC_ISTREAM_OPERATOR(sint16, signed int);
NLMISC_ADD_BASIC_ISTREAM_OPERATOR(uint32, unsigned int);
NLMISC_ADD_BASIC_ISTREAM_OPERATOR(sint32, signed int);

#endif // _MSC_VER < 1300


template <class _CharT, class _Traits>
std::basic_istream<_CharT, _Traits>& __cdecl
operator>>(std::basic_istream<_CharT, _Traits>& __is, uint64& __z)
{
    __z = 0;
    bool neg = false;
    char c;
    do
    {
        __is >> c;
    }
    while (isspace(c));

    if (c == '-')
    {
        neg = true;
        __is >> c;
    }

    while (isdigit(c))
    {
        __z *= 10;
        __z += c-'0';
        __is >> c;
        if (__is.fail())
            break;
    }

    if (neg) __z = 0;

    return __is;
}

template <class _CharT, class _Traits>
std::basic_ostream<_CharT, _Traits>& __cdecl
operator<<(std::basic_ostream<_CharT, _Traits>& __os, const uint64& __z)
{
    std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __res;

    if (__z == 0)
    {
        __res << '0';
    }
    else
    {
        std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __tmp;
        uint64  __z2 = __z;
        while (__z2 != 0)
        {
            __tmp << (char)((__z2%10)+'0');
            __z2 /= 10;
        }

        uint __s = __tmp.str().size();
        for (uint i = 0; i < __s; i++)
            __res << __tmp.str()[__s - 1 - i];
    }
    return __os << __res.str();
}

template <class _CharT, class _Traits>
std::basic_istream<_CharT, _Traits>& __cdecl
operator>>(std::basic_istream<_CharT, _Traits>& __is, sint64& __z)
{
    __z = 0;
    bool neg = false;
    char c;
    do
    {
        __is >> c;
    }
    while (isspace(c));

    if (c == '-')
    {
        neg = true;
        __is >> c;
    }

    while (isdigit(c))
    {
        __z *= 10;
        __z += c-'0';
        __is >> c;
        if (__is.fail())
            break;
    }

    if (neg) __z = -__z;

    return __is;
}

template <class _CharT, class _Traits>
std::basic_ostream<_CharT, _Traits>& __cdecl
operator<<(std::basic_ostream<_CharT, _Traits>& __os, const sint64& __z)
{
    std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __res;

    if (__z == 0)
    {
        __res << '0';
    }
    else
    {
        sint64  __z2 = __z;

        if (__z2 < 0)
        {
            __res << '-';
        }

        std::basic_ostringstream<_CharT, _Traits, std::allocator<_CharT> > __tmp;
        while (__z2 != 0)
        {
            if (__z2 < 0)
            {
                __tmp << (char)((-(__z2%10))+'0');
            }
            else
            {
                __tmp << (char)((__z2%10)+'0');
            }
            __z2 /= 10;
        }

        uint __s = __tmp.str().size();
        for (uint i = 0; i < __s; i++)
            __res << __tmp.str()[__s - 1 - i];
    }
    return __os << __res.str();
}

#endif // NL_OS_WINDOWS
*/

class CLog;

void displayByteBits( uint8 b, uint nbits, sint beginpos, bool displayBegin, NLMISC::CLog *log );

void displayDwordBits( uint32 b, uint nbits, sint beginpos, bool displayBegin, NLMISC::CLog *log );

#ifdef NL_OS_WINDOWS
inline int nlisprint(int c)
{
    if(c>255||c<0) return 0;
    return isprint(c);
}
#else
#define nlisprint isprint
#endif

// Open an url in a browser
bool openURL (const char *url);

// Open a document
bool openDoc (const char *document);

// AntiBug method that return an epsilon if x==0, else x
inline float    favoid0(float x)
{
    if(x==0)    return 0.00001f;
    return x;
}
inline double   davoid0(double x)
{
    if(x==0)    return 0.00001;
    return x;
}
// AntiBug method that return 1 if x==0, else x
template<class T>
inline T        iavoid0(T x)
{
    if(x==0)    return 1;
    return x;
}


} // NLMISC

#endif  // NL_COMMON_H