commondefs.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          Mar 2006
________________________________________________________________________

 Some very commonly used macros.

-*/

#include "basicmod.h"
#include "plfdefs.h"

#include <stdexcept>
#include <new>


//--- FP rounding and equality

template <class RT,class T>
inline RT roundOff( T x )       { return (RT)(x); }

template <class RT>
inline RT roundOff( double x )  { return (RT) ((x)>0 ? (x)+.5 : (x)-.5); }

template <class RT>
inline RT roundOff( float x )   { return (RT) ((x)>0 ? (x)+.5f : (x)-.5f); }

template <class T>
inline void Swap( T& a, T& b )                  { T tmp = a; a = b; b = tmp; }

template <class fT,class eT>
inline bool isFPZero( fT v, eT eps )            { return v < eps && v > -eps; }

template <class T1,class T2,class eT>
inline bool isFPEqual( T1 v1, T2 v2, eT eps )   { return isFPZero(v1-v2,eps); }

template <class T>
inline T getLimited( T v, T min, T max )
{ return v<min ? min : (v>max ? max : v); }


#define mRounded(typ,x)         roundOff<typ>( x )
#define mNINT32(x)              mRounded( od_int32, x )
#define mNINT64(x)              mRounded( od_int64, x )

#define mMAX(x,y)               ((x)>(y) ? (x) : (y))
#define mMIN(x,y)               ((x)<(y) ? (x) : (y))
#define mLimited(v,min,max)     getLimited( v, min, max )

#define mIsZero(x,eps)          isFPZero( x, eps )
#define mIsEqual(x,y,eps)       isFPEqual( x, y, eps )
#define mIsEqualWithUdf(x,y,e)  ((mIsUdf(x) && mIsUdf(y)) || mIsEqual(x,y,e) )
#define mDefEpsF                (1e-10f)
#define mDefEpsD                (1e-10)
#define mDefEps                 mDefEpsD


//--- Math-related constants

#ifndef M_PI
# define M_PI           3.14159265358979323846
#endif
#ifndef M_PIl
# define M_PIl          3.1415926535897932384626433832795029L
#endif
#ifndef M_2PI
# define M_2PI          6.28318530717958647692
#endif
#ifndef M_PI_2
# define M_PI_2         1.57079632679489661923
#endif
#ifndef M_PI_4
# define M_PI_4         0.78539816339744830962
#endif
#ifndef M_SQRT2
#  define M_SQRT2       1.41421356237309504880168872421
#endif
#ifndef M_PIf
# define M_PIf          3.14159265358979323846f
#endif
#ifndef M_2PIf
# define M_2PIf         6.28318530717958647692f
#endif
#ifndef M_PI_2f
# define M_PI_2f        1.57079632679489661923f
#endif
#ifndef M_PI_4f
# define M_PI_4f        0.78539816339744830962f
#endif
#ifndef M_SQRT2f
#  define M_SQRT2f      1.41421356237309504880168872421f
#endif

#ifndef MAXFLOAT
# define MAXFLOAT       3.4028234663852886e+38F
#endif
#ifndef MAXDOUBLE
# define MAXDOUBLE      1.7976931348623157e+308
#endif

#define mFromFeetFactorF        0.3048f
#define mFromFeetFactorD        0.3048
#define mToFeetFactorF          3.2808399f
#define mToFeetFactorD          3.28083989501312336
#define mToPercent(f)           (mIsUdf(f) ? f : f*100)
#define mFromPercent(f)         (mIsUdf(f) ? f : f*0.01)
#define mDeg2RadD               0.017453292519943292
#define mRad2DegD               57.295779513082323
#define mDeg2RadF               0.017453292519943292f
#define mRad2DegF               57.295779513082323f


//--- C++ tools

#define mCast(tp,v)                     ((tp)(v))

# define mDynamicCast(typ,out,in)       out = dynamic_cast< typ >( in );
# define mDynamicCastGet(typ,out,in)    typ mDynamicCast(typ,out,in)

#define mDefSetupClssMemb(clss,typ,memb) \
        typ     memb##_; \
        clss&   memb( typ val )         { memb##_ = val; return *this; }

#define mDefSetupMemb(typ,memb) mDefSetupClssMemb(Setup,typ,memb)

#define mDefNoAssignmentOper(clss) \
private: \
    inline clss& operator =( const clss& ) \
            { pErrMsg("No assignment"); return *this; }



//--- Covering Windows problems, mainly DLL export/import stuff

#ifdef __win__
# include <stdio.h>
# undef small
# ifndef __func__
#  define __func__ __FUNCTION__
# endif
#endif

#ifdef __msvc__
# include "msvcdefs.h"
#else
# define dll_export
# define dll_import
# define mMaxFilePathLength     255
#endif

#define mExp( module )                  Export_##module
#define mExpClass( module )             class mExp( module )
#define mExpStruct( module )            struct mExp( module )

#define mGlobal( module )               mExp( module )
#define mClass( module )                class
#define mStruct( module )               mExpStruct( module )
#define mExtern( module )               extern mExp( module )
#define mExternC( module)               extern "C" mExp( module )

#define mExportInst( mod, tp )          Extern_##mod tp mExp(mod)
#define mExportTemplClassInst(mod)      mExportInst(mod,template class)


//--- Local static variable initialization ---
// The circus below is because the M$ VS compiler does not properly initialise
// static local variables under MT conditions (baffling, but true).
// End result: never declare static local variables other than with the
// mDefineStaticLocalObject macro.
// Note that if you want to MT-safely return static local variables, you should
// think about perthreadrepos.h stuff, for example the mDeclStaticString macro.

#ifdef __win__
namespace Threads
{
    mGlobal(Basic) bool lockSimpleSpinWaitLock(volatile int& lock);
    mGlobal(Basic) void unlockSimpleSpinLock(volatile int& lock);
}

#define mLockStaticInitLock( nm ) \
static volatile int nm = 0; \
Threads::lockSimpleSpinWaitLock( nm )

#define mUnlockStaticInitLock( nm ) \
Threads::unlockSimpleSpinLock( nm )

#else

#define mLockStaticInitLock( nm )
#define mUnlockStaticInitLock( nm )

#endif

#define mDefineStaticLocalObject( type, var, init ) \
mLockStaticInitLock( static##var##lck__ ); \
static type var init; \
mUnlockStaticInitLock( static##var##lck__ );


//--- Single-shot initialization support

namespace Threads
{
#if mODVersion < 700
    mGlobal(Basic) bool atomicSetIfValueIs(volatile int&,int,int,int* );
    //Force developer to use three arguments
#else
    mGlobal(Basic) bool atomicSetIfValueIs(volatile int&,int,int,int* = 0 );
#endif
}


#define mIfNotFirstTime(act) \
{ \
    static volatile int _already_visited_ = 0; \
    if ( !Threads::atomicSetIfValueIs( _already_visited_, \
                                       0, 1, 0 ) ) \
        act; \
}


//--- Qt class and namespace handling

#ifndef QT_NAMESPACE
# define mFDQtclass(cls) class cls;
# define mQtclass(cls) ::cls
# define mUseQtnamespace
#else
# define mFDQtclass(cls) namespace QT_NAMESPACE { class cls; }
# define mQtclass(cls) ::QT_NAMESPACE::cls
# define mUseQtnamespace using namespace ::QT_NAMESPACE;
#endif


//--- Large array allocation

#define mTryAlloc(var,stmt) \
{ try { var = new stmt; } catch ( std::bad_alloc ) { var = 0; } }

#define mTryAllocPtrMan(var,stmt) \
{ try { var = new stmt; } catch ( std::bad_alloc ) { var.set( 0 ); } }

#define mDeclareAndTryAlloc(tp,var,stmt) \
    tp var; \
    mTryAlloc(var,stmt)

#define mGetIdxArr(tp,var,sz) \
    tp* var; \
    mTryAlloc(var,tp [sz]) \
    if ( var ) \
        for  ( tp idx=0; idx<sz; idx++ ) \
            var[idx] = idx



#define mDoArrayPtrOperation( type, arr, operation, arrsz, ptrinc ) \
{ \
    type* __curptr = arr; \
    for ( const type* __stopptr = __curptr + arrsz; \
          __curptr!=__stopptr; \
          __curptr ptrinc ) \
    { \
        *__curptr operation; \
    } \
}