Utilities.h

Go to the documentation of this file.

 
 
#ifndef _Utilities_h_
#define _Utilities_h_
 
namespace XPMP2 {
 
//
// MARK: General texts
//
 
#define ERR_ASSERT              "ASSERT FAILED: %s"
#define ERR_EXCEPTION           "EXCEPTION CAUGHT: %s"
 
// Required supplemental files
constexpr const char* RSRC_RELATED      = "related.txt";
constexpr const char* RSRC_REL_OP       = "relOp.txt";
constexpr const char* RSRC_DOC8643      = "Doc8643.txt";
constexpr const char* RSRC_MAP_ICONS    = "MapIcons.png";
constexpr const char* RSRC_OBJ8DATAREFS = "Obj8DataRefs.txt";
 
//
// MARK: Default configuration callbacks
//
 
int     PrefsFuncIntDefault     (const char *, const char *, int _default);
 
//
// MARK: File access helpers
//
 
#if IBM
#define PATH_DELIM_STD '\\'
#else
#define PATH_DELIM_STD '/'
#endif
 
bool ExistsFile (const std::string& filename);
 
bool IsDir (const std::string& path);
 
bool CreateDir(const std::string& path);
 
bool CopyFileIfNewer(const std::string& source, const std::string& destDir);
 
std::list<std::string> GetDirContents (const std::string& path);
 
std::istream& safeGetline(std::istream& is, std::string& t);
 
const std::string& GetXPSystemPath ();
 
std::string StripXPSysDir (const std::string& path);
 
void RemoveExtension (std::string& path);
 
//
// MARK: String helpers
//
 
#define WHITESPACE              " \t\f\v\r\n"
 
std::string& str_tolower(std::string& s);
 
inline std::string& rtrim(std::string& s, const char* t = WHITESPACE)
{
    s.erase(s.find_last_not_of(t) + 1);
    return s;
}
 
inline std::string& ltrim(std::string& s, const char* t = WHITESPACE)
{
    s.erase(0, s.find_first_not_of(t));
    return s;
}
 
inline std::string& trim(std::string& s, const char* t = WHITESPACE)
{
    return ltrim(rtrim(s, t), t);
}
 
inline std::string leftOf(const std::string& s, const std::string& terminators)
{
    return s.substr(0, std::min(s.find_first_of(terminators), s.size()));
}
 
std::vector<std::string> str_tokenize (const std::string s,
                                       const std::string tokens,
                                       bool bSkipEmpty = true);
 
//
// MARK: Math helpers
//
 
constexpr double PI = 3.1415926535897932384626433832795028841971693993751;
 
constexpr float EPSILON_F = 0.00001f;
 
inline bool fequal (float a, float b)
{ return ((a - EPSILON_F) < b) && ((a + EPSILON_F) > b); }
 
 
template <class T>
inline T rad2deg (const T _rad)
{ return (_rad < T(0) ? T(360) : T(0)) + _rad * T(180) / T(PI); }
 
template <class T>
inline T deg2rad (const T _deg)
{ return _deg * T(PI) / T(180); }
 
template <class T>
inline T sqr (const T a) { return a*a; }
 
template <class T>
inline T dist (const T x1, const T y1, const T z1,
               const T x2, const T y2, const T z2)
{
    return std::hypot(x1-x2, y1-y2, z1-z2);
}
 
inline float atan2deg (float x, float y)
{ return rad2deg(atan2(x,y)); }
 
inline float angleLocCoord (float x1, float z1, float x2, float z2)
{ return rad2deg(atan2(z2-z1,x2-x1) + float(PI/2.0)); }
 
float headDiff (float head1, float head2);
 
template <class numT>
numT headNormalize (numT _head)
{
    if (_head < numT(0))
        _head += std::ceil(_head/-numT(360)) * numT(360);
    else if (_head >= numT(360))
        _head -= std::floor(_head/numT(360)) * numT(360);
    return _head;
}
 
std::valarray<float> HeadPitch2Vec (const float head, const float pitch);
 
std::valarray<float> HeadPitchRoll2Normal(const float head, const float pitch, const float roll);
 
//
// MARK: Misc
//
 
float UpdateCachedValuesGetNetwTime ();
 
float GetMiscNetwTime ();
 
std::string GetMiscNetwTimeStr (float _time = NAN);
 
const char* GetGraphicsDriverTxt ();
 
bool IsPaused ();
 
bool IsViewExternal ();
 
bool CheckEverySoOften (float& _lastCheck, float _interval, float _now);
 
inline bool CheckEverySoOften (float& _lastCheck, float _interval)
{ return CheckEverySoOften(_lastCheck, _interval, GetMiscNetwTime()); }
 
//
// MARK: Logging Support
//
 
#if defined(__clang__) || defined(__GNUC__)
#define XPMP2_FMTARGS(FMT)  __attribute__((format(printf, FMT, FMT+1)))
#else
#define XPMP2_FMTARGS(FMT)
#endif
 
enum logLevelTy {
    logDEBUG = 0,       
    logINFO,            
    logWARN,            
    logERR,             
    logFATAL,           
    logMSG              
};
 
const char* LogGetString ( const char* szFile, int ln, const char* szFunc, logLevelTy lvl, const char* szMsg, va_list args );
             
void LogMsg ( const char* szFile, int ln, const char* szFunc, logLevelTy lvl, const char* szMsg, ... ) XPMP2_FMTARGS(5);
 
//
// MARK: Logging macros
//
 
#define LOG_MSG(lvl,...)  {                                         \
    if (lvl >= XPMP2::glob.logLvl)                                  \
    {LogMsg(__FILE__, __LINE__, __func__, lvl, __VA_ARGS__);}       \
}
 
#define LOG_MATCHING(lvl,...)  {                                    \
    if (XPMP2::glob.bLogMdlMatch && lvl >= glob.logLvl)             \
    {LogMsg(__FILE__, __LINE__, __func__, lvl, __VA_ARGS__);}       \
}
 
#define THROW_ERROR(...)                                            \
throw XPMP2Error(__FILE__, __LINE__, __func__, __VA_ARGS__);
 
#define LOG_ASSERT(cond)                                            \
    if (!(cond)) {                                                  \
        THROW_ERROR(ERR_ASSERT,#cond);                              \
    }
 
#define CATCH_AC(ac)                                                \
    catch (const std::exception& e) {                               \
        LOG_MSG(logFATAL, ERR_EXCEPTION, e.what());                 \
        (ac).SetInvalid();                                          \
    }                                                               \
    catch (...) {                                                   \
        LOG_MSG(logFATAL, ERR_EXCEPTION, "<unknown>");              \
        (ac).SetInvalid();                                          \
    }
 
 
//
// MARK: Compiler differences
//
 
#if APL == 1 || LIN == 1
// not quite the same but close enough for our purposes
inline void strncpy_s(char * dest, size_t destsz, const char * src, size_t count)
{
    strncpy(dest, src, std::min(destsz,count)); dest[destsz - 1] = 0;
}
 
// these simulate the VC++ version, not the C standard versions!
inline struct tm *gmtime_s(struct tm * result, const time_t * time)
{ return gmtime_r(time, result); }
inline struct tm *localtime_s(struct tm * result, const time_t * time)
{ return localtime_r(time, result); }
 
#endif
 
#define STRCPY_S(dest,src) strncpy_s(dest,sizeof(dest),src,sizeof(dest)-1)
#define STRCPY_ATMOST(dest,src) strncpy_s(dest,sizeof(dest),strAtMost(src,sizeof(dest)-1).c_str(),sizeof(dest)-1)
 
// XCode/Linux don't provide the _s functions, not even with __STDC_WANT_LIB_EXT1__ 1
#if APL
inline int strerror_s( char *buf, size_t bufsz, int errnum )
{ return strerror_r(errnum, buf, bufsz); }
#elif LIN
inline int strerror_s( char *buf, size_t bufsz, int errnum )
{ strerror_r(errnum, buf, bufsz); return 0; }
#endif
 
// In case of Mac we need to prepare for HFS-to-Posix path conversion
#if APL
std::string TOPOSIX (const std::string& p);
std::string FROMPOSIX (const std::string& p);
#else
inline std::string TOPOSIX (const std::string& p) { return p; }
inline std::string FROMPOSIX (const std::string& p) { return p; }
#endif
 
// MARK: Thread names
#ifdef DEBUG
// This might not work on older Windows version, which is why we don't publish it in release builds
#if IBM
#define SET_THREAD_NAME(sName) SetThreadDescription(GetCurrentThread(), L##sName)
#elif APL
#define SET_THREAD_NAME(sName) pthread_setname_np(sName)
#elif LIN
#define SET_THREAD_NAME(sName) pthread_setname_np(pthread_self(),sName)
#endif
#else
#define SET_THREAD_NAME(sName)
#endif
 
}       // namespace XPMP2
 
#endif