lean.h

/*****************************************************/
/* lean                         (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN
#define LEAN


#ifdef DOXYGEN_READ_THIS

    #define LEAN_BUILD_LIB
    #undef LEAN_BUILD_LIB
    
    #define LEAN_HEADER_ONLY
    #undef LEAN_HEADER_ONLY
    
    #define LEAN_MIN_DEPENDENCY
    #undef LEAN_MIN_DEPENDENCY

    #define LEAN_MAYBE_EXPORT
    #undef LEAN_MAYBE_EXPORT

    #define LEAN_INTEGRATE_ONCE
    #undef LEAN_INTEGRATE_ONCE
#endif




#ifdef DOXYGEN_READ_THIS

    #define LEAN_DEBUG_BUILD
    #undef LEAN_DEBUG_BUILD

    #define LEAN_RELEASE_BUILD
    #undef LEAN_RELEASE_BUILD
#else

#ifdef _DEBUG

    #define LEAN_DEBUG_BUILD
#else

    #define LEAN_RELEASE_BUILD
#endif

#endif

#ifndef LEAN_MAYBE_EXPORT

    #define LEAN_MAYBE_EXPORT
#endif

#ifdef _MSC_VER

    #pragma warning(push)
    // Decorated name length exceeded all the time by various STL containers
    #pragma warning(disable : 4503)
    // Can't do anything about methods not being inlined
    #pragma warning(disable : 4714)
    // Formal parameters named for documentation purposes
    #pragma warning(disable : 4100)
    // Constant conditional expressions occur quite often in template code
    #pragma warning(disable : 4127)
    // Sometimes, using 'this' in initializier lists is unavoidable
    #pragma warning(disable : 4355)
    // We actually want arrays & PODs to be default-initialized
    #pragma warning(disable : 4351)
    #pragma warning(disable : 4345)
    // Assignment operators suppressed intentionally
    #pragma warning(disable : 4512)
    // Extern template now standard
    #pragma warning(disable : 4231)

#endif

#ifdef LEAN_DEBUG_BUILD
    #include <cassert>
    #ifdef _MSC_VER

        #define LEAN_ASSERT(expr) ( assert(expr), __assume(expr) )
    #else

        #define LEAN_ASSERT(expr) assert(expr)
    #endif

    #define LEAN_ASSERT_DEBUG(expr) assert(expr)
#else
    #ifdef _MSC_VER

        #define LEAN_ASSERT(expr) __assume(expr)
    #else

        #define LEAN_ASSERT(expr)
    #endif

    #define LEAN_ASSERT_DEBUG(expr)
#endif

#define LEAN_ASSERT_NOT_NULL(expr) ( LEAN_ASSERT(expr != nullptr), expr )

#define LEAN_ASSERT_NOT_NULL_DEBUG(expr) ( LEAN_ASSERT_DEBUG(expr != nullptr), expr )

#ifdef _MSC_VER

    #define LEAN_INLINE __forceinline

    #define LEAN_NOINLINE __declspec(noinline) inline

    #define LEAN_NOLTINLINE __declspec(noinline)

    #ifndef LEAN_DEBUG_BUILD

        #define LEAN_OPTIMIZE_DEFAULT_DESTRUCTOR
    #endif
#else

    #define LEAN_INLINE inline

    #define LEAN_NOINLINE inline

    #define LEAN_NOLTINLINE
#endif

#define LEAN_NOTINLINE LEAN_NOLTINLINE

#ifdef _MSC_VER

    #define LEAN_INTERFACE __declspec(novtable)
#else

    #define LEAN_INTERFACE
#endif

#if !defined(LEAN_INTEGRATE_ONCE) && defined(LEAN_HEADER_ONLY) && !defined(LEAN_BUILD_LIB)

    #define LEAN_LINK_SELECT(linklib, headeronly) headeronly
#else

    #define LEAN_LINK_SELECT(linklib, headeronly) linklib

    #define LEAN_LINKING 1
#endif

#if !defined(LEAN_LINKING) || defined(LEAN_INTEGRATE_ONCE)

    #define LEAN_INCLUDE_LINKED 1
#endif

#define LEAN_MAYBE_LINK LEAN_LINK_SELECT(, LEAN_NOINLINE)

#define LEAN_ALWAYS_LINK LEAN_LINK_SELECT(LEAN_NOLTINLINE, LEAN_NOINLINE)

#if !defined(LEAN_INTEGRATE_ONCE) && (defined(LEAN_HEADER_ONLY) || !defined(LEAN_MIN_DEPENDENCY)) && !defined(LEAN_BUILD_LIB)

    #define LEAN_INLINE_SELECT(maxdep, mindep) maxdep

    #define LEAN_INLINING 1
#else

    #define LEAN_INLINE_SELECT(maxdep, mindep) mindep
#endif

#if defined(LEAN_INLINING) || defined(LEAN_INTEGRATE_ONCE)

    #define LEAN_INCLUDE_INLINED 1
#endif

#define LEAN_MAYBE_INLINE LEAN_INLINE_SELECT(inline, )

#define LEAN_NEVER_INLINE LEAN_INLINE_SELECT(LEAN_NOINLINE, LEAN_NOLTINLINE)



namespace lean
{

LEAN_INLINE void check(bool value)
{
    LEAN_ASSERT_DEBUG(value);
}

template <class Type>
LEAN_INLINE const Type& min(const Type &a,const Type &b)
{
    return (a < b) ? a : b;
}

template <class Type>
LEAN_INLINE const Type& max(const Type &a, const Type &b)
{
    return (a < b) ? b : a;
}

template <class Type>
LEAN_INLINE Type* addressof(Type& value)
{
    // Use C-style cast as const_casting would only make it worse
    return reinterpret_cast<Type*>( &(char&)value );
}

template <class Type, size_t Size>
LEAN_INLINE size_t arraylen(Type (&)[Size])
{
    return Size;
}

} // namespace


#ifdef DOXYGEN_READ_THIS


    #define LEAN_NO_CHECK
    #undef LEAN_NO_CHECK


    #define LEAN_NO_MINMAX
    #undef LEAN_NO_MINMAX
#endif

#ifndef LEAN_NO_CHECK   
    using lean::check;
#endif

#ifndef LEAN_NO_MINMAX  
    using lean::min;
    using lean::max;
#endif

#include "macros.h"
#include "cpp0x.h"
#include "types.h"

#endif