types.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/kernel/SF_Types.h"
#include <math.h>

//------------------------------------------------------------------------------------------------
// KY_NO_LOG_OUTPUT is different from KY_NO_DEBUG_OUTPUT
// => KY_NO_DEBUG_OUTPUT disables KY_DEBUG_XXX macros
// => KY_NO_LOG_OUTPUT disables all KY_LOG_XXX macros and Kaim::LogStream() <<
#if defined(KY_CONFIG_RELEASE)
# define KY_NO_LOG_OUTPUT
#endif

// The comments are necessary to avoid doxygen warning: explicit link request to 'KyInt8' could not be resolved

typedef std::int8_t    KyInt8;  
typedef std::int16_t   KyInt16; 
typedef std::int32_t   KyInt32; 
typedef std::int64_t   KyInt64; 

typedef std::uint8_t   KyUInt8;  
typedef std::uint16_t  KyUInt16; 
typedef std::uint32_t  KyUInt32; 
typedef std::uint64_t  KyUInt64; 

typedef float          KyFloat32; 
typedef double         KyFloat64; 

// when we drop vc11, let's prefer the using syntax

// using KyInt8    = std::int8_t;
// using KyInt16   = std::int16_t;
// using KyInt32   = std::int32_t;
// using KyInt64   = std::int64_t;

// using KyUInt8   = std::uint8_t;
// using KyUInt16  = std::uint16_t;
// using KyUInt32  = std::uint32_t;
// using KyUInt64  = std::uint64_t;

// using KyFloat32 = float;
// using KyFloat64 = double;


//----------------------------------------------------------------------------------------
// MAXVAL and MINVAL

#define KyInt8MAXVAL    0x7F   
#define KyInt8MINVAL    0x80   

#define KyInt16MAXVAL   0x7FFF 
#define KyInt16MINVAL   0x8000 

#define KyInt32MAXVAL   0x7FFFFFFF 
#define KyInt32MINVAL   0x80000000 

#define KyInt64MAXVAL   0x7FFFFFFFFFFFFFFFLL 
#define KyInt64MINVAL   0x8000000000000000LL 

#define KyUInt8MAXVAL   0xFF       
#define KyUInt16MAXVAL  0xFFFF     
#define KyUInt32MAXVAL  0xFFFFFFFF 
#define KyUInt64MAXVAL  0xFFFFFFFFFFFFFFFFULL 

#define KyFloat32MAXVAL 3.402823466e+38f 

//----------------------------------------------------------------------------------------
// KY_PERF_MARKERS_ENABLED
#if defined(KY_CONFIG_DEV)
# define KY_PERF_MARKERS_ENABLED
#endif

//----------------------------------------------------------------------------------------
// KY_DEPRECATED
#ifndef KY_DEPRECATED
# if defined (KY_CC_MSVC)
#  define KY_DEPRECATED(expr) __declspec(deprecated) expr
# elif defined (KY_CC_GCC) || defined(KY_CC_CLANG)
#  define KY_DEPRECATED(expr) expr __attribute__((deprecated))
# else
#  define KY_DEPRECATED(expr) expr
# endif
#endif

//----------------------------------------------------------------------------------------
// KyResult

namespace Kaim
{

struct Result
{
    static Result Success() { return Result(1); }
    static Result Failure() { return Result(0); }
    static Result Error()   { return Result(0); }

    static bool Check(Result result) { return result == Success(); }
    static bool Fail(Result result) { return result == Failure(); }

    explicit Result(KyUInt8 code_) : code(code_) {}

    bool operator==(Result r) const { return code == r.code; }
    bool operator!=(Result r) const { return code != r.code; }
    operator bool() const { return code != 0; }
    bool operator!() const { return code == 0; }

    KyUInt8 code;
};

}

typedef Kaim::Result KyResult; // using KyResult = Kaim::Result;

#define KY_ERROR KyResult::Error()

// use `result == KY_SUCCESS to test for success
#define KY_SUCCESS KyResult::Success()

// deprecated since 2.17.0, use == KY_ERROR instead
KY_DEPRECATED(bool KY_FAILED(KyResult result));
KY_DEPRECATED(bool KY_SUCCEEDED(KyResult result));
inline bool KY_FAILED(KyResult result)    { return result == Kaim::Result::Error();   }
inline bool KY_SUCCEEDED(KyResult result) { return result == Kaim::Result::Success(); }

#define KY_TRY(expr) { KyResult result = (expr); if (result == Kaim::Result::Error()) { return result; }}


//----------------------------------------------------------------------------------------
// KY_MACRO_START KY_MACRO_END
#if defined(KY_CC_MSVC)
# define KY_MACRO_START     \
    do {                    \
    KY_PUSH_COMPILE_WARNING \
    KY_PRAGMA_WARNING_DISABLE(4127)
# define KY_MACRO_END \
    } while(0)        \
    KY_POP_COMPILE_WARNING
#else
# define KY_MACRO_START do {
# define KY_MACRO_END } while(0)
#endif


//----------------------------------------------------------------------------------------
// KY_DISABLE_ALIGN_WARNING_START KY_DISABLE_ALIGN_WARNING_END
#if defined(KY_CC_MSVC)
# define KY_DISABLE_ALIGN_WARNING_START KY_PUSH_COMPILE_WARNING KY_PRAGMA_WARNING_DISABLE(4324) // structure was padded due to __declspec(align())
# define KY_DISABLE_ALIGN_WARNING_END KY_POP_COMPILE_WARNING
#else
# define KY_DISABLE_ALIGN_WARNING_START
# define KY_DISABLE_ALIGN_WARNING_END
#endif


//----------------------------------------------------------------------------------------
// KY_FORCE_ALIGNMENT
#if defined (KY_CC_MSVC)
# define KY_FORCE_ALIGNMENT(alignment, declaration) __declspec(align(alignment)) declaration
#elif defined (KY_CC_GCC) || defined (KY_CC_CLANG)
# define KY_FORCE_ALIGNMENT(alignment, declaration) declaration __attribute__((aligned(alignment)))
#endif


//----------------------------------------------------------------------------------------
// ArraySize
namespace Kaim
{
template<typename T, KyUInt32 N>
KY_INLINE KyUInt32 ArraySize(T (&) [N]) { return N; }
}


//----------------------------------------------------------------------------------------
// KY_CLASS_WITHOUT_COPY
#define KY_CLASS_WITHOUT_COPY(ClassName) \
private:                                 \
    ClassName(const ClassName& rhs);     \
    ClassName& operator=(const ClassName& rhs);


namespace Kaim
{
//----------------------------------------------------------------------------------------
template <typename F> struct ScopeExit
{
    explicit ScopeExit(const F& func_) : func(func_), active(true) {}
    ~ScopeExit()
    {
        if (active)
            func();
    }

    // when we drop vc11, let's use the = delete syntax
    //ScopeExit(ScopeExit<F>&) = delete;
    //ScopeExit& operator=(ScopeExit<F>&) = delete;
private:
    ScopeExit(ScopeExit<F>&);
    ScopeExit& operator=(ScopeExit<F>&);

public:
    ScopeExit(ScopeExit<F>&& moved) : func(moved.func), active(moved.active) { moved.active = false; }

    ScopeExit& operator=(ScopeExit<F>&& moved)
    {
        func = moved.func;
        active = moved.active;
        moved.active = false;
    }

private:
    F func;
    bool active;
};
// Get type F from lambda/functor/function pointer
template <typename F> inline ScopeExit<F> MakeScopeExit(const F& func) { return ScopeExit<F>(func); }
}

//----------------------------------------------------------------------------------------
#if defined(KY_CC_MSVC) && (KY_CC_MSVC <= 1800) // vc12 or previous
#define KY_RETURN_MOVE(x) std::move(x)
#else
#define KY_RETURN_MOVE(x) x
#endif