kApiDef.h

Go to the documentation of this file.

#ifndef K_API_API_DEF_H
#define K_API_API_DEF_H

#include <kApi/kApiCfg.h>

#define kCall           xkCall              
#define kDlCall         xkDlCall            

#if defined(K_EMIT)
#   define kFx(TYPE)    kExportFx(TYPE)     
#   define kDx(TYPE)    kExportDx(TYPE)     
#else
#   define kFx(TYPE)    kImportFx(TYPE)     
#   define kDx(TYPE)    kImportDx(TYPE)     
#endif

#define kInlineFx(TYPE) xkInlineFx(TYPE)    

typedef void (kCall* kFunction)();          

typedef xk8u k8u;          

#define k8U_MIN    (0)             
#define k8U_MAX    (255U)          
#define k8U_NULL   (k8U_MAX)       

typedef xk16u k16u;           

#define k16U_MIN   (0)             
#define k16U_MAX   (65535U)        
#define k16U_NULL  (k16U_MAX)      

typedef xk32u k32u;   

#define k32U_MIN   (0)             
#define k32U_MAX   (4294967295U)   
#define k32U_NULL  (k32U_MAX)      

typedef xk64u k64u;         

#define k64U(CONST) xk64U(CONST)                    
#define k64U_MIN    k64U(0)                         
#define k64U_MAX    k64U(18446744073709551615)      
#define k64U_NULL  (k64U_MAX)                       

#define kINFINITE   k64U_MAX                        


typedef xk8s k8s;       

#define k8S_MAX    (127)               
#define k8S_MIN    (-k8S_MAX -1)       
#define k8S_NULL   (k8S_MIN)           

typedef xk16s k16s;      

#define k16S_MAX   (32767)             
#define k16S_MIN   (-k16S_MAX -1)      
#define k16S_NULL  (k16S_MIN)          

typedef xk32s k32s;      

#define k32S_MAX   (2147483647)        
#define k32S_MIN   (-k32S_MAX -1)      
#define k32S_NULL  (k32S_MIN)          

typedef xk64s k64s;      

#define k64S(CONST) xk64S(CONST)                
#define k64S_MAX    k64S(9223372036854775807)   
#define k64S_MIN    (-k64S_MAX -1)              
#define k64S_NULL   (k64S_MIN)                  

typedef k32s kBool;

#define kFALSE     (0)     
#define kTRUE      (1)     

typedef xk32f k32f;         

#define k32F_MIN   (1.175494351e-38F)      
#define k32F_MAX   (3.402823466e+38F)      
#define k32F_NULL  (-k32F_MAX)             
#define k32F_DIGITS (9)                    

kInlineFx(kBool) k32f_IsNull(k32f value)
{
    return (value == k32F_NULL);
}

typedef xk64f k64f;        

#define k64F_MIN   (2.2250738585072014e-308)   
#define k64F_MAX   (1.7976931348623157e+308)   
#define k64F_NULL  (-k64F_MAX)                 
#define k64F_DIGITS (17)                       

kFx(k32s) k64f_IsNanOrInf(k64f value);

kInlineFx(kBool) k64f_IsNull(k64f value)
{
    return (value == k64F_NULL);
}

typedef xkByte kByte;                           

typedef xkSize kSize;   

#define kSIZE_MAX           xkSIZE_MAX      
#define kSIZE_NULL          kSIZE_MAX       

kInlineFx(kSize) kSize_Align(kSize value, kSize to)
{
    return ((value >> to) + !!(value & ((1 << to) - 1))) << to;
}

typedef xkSSize kSSize;   

#define kSSIZE_MIN       xkSSIZE_MIN        
#define kSSIZE_MAX       xkSSIZE_MAX        
#define kSSIZE_NULL      kSSIZE_MIN         

typedef void* kPointer;   

#define kNULL   (0)     


kInlineFx(void*) kPointer_ByteOffset(const void* pointer, kSSize offset)
{
    return (kByte*)pointer + offset;
}

kInlineFx(void*) kPointer_ItemOffset(const void* pointer, kSSize itemIndex, kSize itemSize)
{
    return kPointer_ByteOffset(pointer, itemIndex*(kSSize)itemSize);
}

kInlineFx(kSSize) kPointer_Diff(void* a, void* b)
{
    return (kSSize)a - (kSSize)b;
}

#define kPointer_ReadAs(POINTER, TYPE)                            \
    (*(TYPE*)(POINTER))

#define kPointer_WriteAs(POINTER, VALUE, TYPE)                  \
    (*(TYPE*)(POINTER) = (TYPE)(VALUE))

#define kIsNull(POINTER)    \
     ((POINTER) == kNULL)         

typedef xkChar kChar;                           

kInlineFx(kChar) kChar_ToLower(kChar ch)
{
    return (ch >= 'A' && ch <= 'Z') ? (ch - 'A' + 'a') : ch;
}

kInlineFx(kChar) kChar_ToUpper(kChar ch)
{
    return (ch >= 'a' && ch <= 'z') ? (ch - 'a' + 'A') : ch;
}

kInlineFx(kBool) kChar_IsSpace(kChar ch)
{
    return ch == ' ';
}

kInlineFx(kBool) kChar_IsLetter(kChar ch)
{
    return ((ch >= 'a') && (ch <= 'z') ) || ((ch >= 'A') && (ch <= 'Z'));
}

kInlineFx(kBool) kChar_IsDigit(kChar ch)
{
    return ch >= '0' && ch <= '9';
}

typedef kChar kText16[16];    

typedef kChar kText32[32];    

typedef kChar kText64[64];    

typedef kChar kText128[128];  

typedef kChar kText256[256];  

typedef k32s kStatus; 

#define kERROR_STATE               (-1000)     
#define kERROR_NOT_FOUND           (-999)      
#define kERROR_COMMAND             (-998)      
#define kERROR_PARAMETER           (-997)      
#define kERROR_UNIMPLEMENTED       (-996)      
#define kERROR_MEMORY              (-994)      
#define kERROR_TIMEOUT             (-993)      
#define kERROR_INCOMPLETE          (-992)      
#define kERROR_STREAM              (-991)      
#define kERROR_CLOSED              (-990)      
#define kERROR_VERSION             (-989)      
#define kERROR_ABORT               (-988)      
#define kERROR_ALREADY_EXISTS      (-987)      
#define kERROR_NETWORK             (-986)      
#define kERROR_HEAP                (-985)      
#define kERROR_FORMAT              (-984)      
#define kERROR_READ_ONLY           (-983)      
#define kERROR_WRITE_ONLY          (-982)      
#define kERROR_BUSY                (-981)      
#define kERROR_CONFLICT            (-980)      
#define kERROR_OS                  (-979)      
#define kERROR_DEVICE              (-978)      
#define kERROR_FULL                (-977)      
#define kERROR_IN_PROGRESS         (-976)      
#define kERROR                     (0)         
#define kOK                        (1)         

kFx(const kChar*) kStatus_Name(kStatus status); 

kInlineFx(kBool) kIsError(kStatus status)
{
    return status != kOK; 
}

kInlineFx(kBool) kSuccess(kStatus status) 
{
    return status == kOK; 
}

#define kCheck(EXPRESSION)      \
    xkCheck(EXPRESSION)

#define kCheckTrue(EXPRESSION, STATUS)      \
    xkCheckTrue(EXPRESSION, STATUS)

#define kCheckArgs(EXPRESSION)      \
    xkCheckArgs(EXPRESSION)

#define kCheckState(EXPRESSION)     \
    xkCheckState(EXPRESSION)

#define kTry        \
    xkTry

#define kThrow(EXPRESSION)      \
    xkThrow(EXPRESSION)

#define kTest(EXPRESSION)       \
    xkTest(EXPRESSION)

#define kTestTrue(EXPRESSION, STATUS)       \
    xkTestTrue(EXPRESSION, STATUS)

#define kTestArgs(EXPRESSION)       \
    xkTestArgs(EXPRESSION)

#define kTestState(EXPRESSION)      \
    xkTestState(EXPRESSION)

#define kCatch(STATUS_POINTER)      \
    xkCatch(STATUS_POINTER)

#define kEndCatch(STATUS)       \
    xkEndCatch(STATUS)

#define kFinally        \
    xkFinally 

#define kEndFinally()      \
    xkEndFinally()

#define kCatchEx(STATUS_POINTER)    \
    xkCatchEx(STATUS_POINTER)

#define kEndCatchEx(STATUS)     \
    xkEndCatchEx(STATUS)

#define kFinallyEx      \
    xkFinallyEx 

#define kEndFinallyEx()             \
    xkEndFinallyEx()

#define kAssert(EXPRESSION)         \
    xkAssert(EXPRESSION)

#define kAssertType(OBJECT, SYMBOL)     \
    xkAssertType(OBJECT, SYMBOL)

#define kTrace(TAG)                 \
    xkTrace(TAG)

typedef k32u kVersion;

#define kVERSION_NULL       (k32U_NULL)     // kVersion invalid value.

kInlineFx(kVersion) kVersion_Create(k32u major, k32u minor, k32u release, k32u build)
{
    return (major   & 0xFF) << 24 | 
           (minor   & 0xFF) << 16 |
           (release & 0xFF) << 8  | 
           (build   & 0xFF);
}

#define kVersion_Stringify_(MAJOR, MINOR, RELEASE, BUILD)               \
    xkStringize(MAJOR) "." xkStringize(MINOR) "." xkStringize(RELEASE) "." xkStringize(BUILD)

kFx(kStatus) kVersion_Parse(kVersion* version, const kChar* buffer);

kFx(kStatus) kVersion_Format(kVersion version, kChar* buffer, kSize capacity);

kInlineFx(k32s) kVersion_Compare(kVersion version1, kVersion version2)
{
    return (k32s)version1 - (k32s)version2; 
}

kInlineFx(k8u) kVersion_Major(kVersion version)
{
    return (version >> 24) & 0xFF; 
}

kInlineFx(k8u) kVersion_Minor(kVersion version)
{
    return (version >> 16) & 0xFF; 
}

kInlineFx(k8u) kVersion_Release(kVersion version)
{
    return (version >> 8) & 0xFF; 
}

kInlineFx(k8u) kVersion_Build(kVersion version)
{
    return (version) & 0xFF; 
}

typedef k32s kEndianness; 

#define kENDIANNESS_LITTLE          (1)             
#define kENDIANNESS_BIG             (2)             

kInlineFx(kEndianness) kEndianness_Host()
{
    return K_ENDIANNESS;
}

kInlineFx(kBool) kEndianness_ShouldReverse(kEndianness endianness)    
{
    return endianness != kEndianness_Host();
}

kFx(kStatus) k8u_Format(k8u value, kChar* buffer, kSize capacity);

kFx(kStatus) k8u_Parse(k8u* value, const kChar* str);

kFx(kStatus) k8s_Format(k8s value, kChar* buffer, kSize capacity);

kFx(kStatus) k8s_Parse(k8s* value, const kChar* str);

kFx(kStatus) k16u_Format(k16u value, kChar* buffer, kSize capacity);

kFx(kStatus) k16u_Parse(k16u* value, const kChar* str);

kFx(kStatus) k16s_Format(k16s value, kChar* buffer, kSize capacity);

kFx(kStatus) k16s_Parse(k16s* value, const kChar* str);

kFx(kStatus) k32u_Format(k32u value, kChar* buffer, kSize capacity);

kFx(kStatus) k32u_Parse(k32u* value, const kChar* str);

kFx(kStatus) k32s_Format(k32s value, kChar* buffer, kSize capacity);

kFx(kStatus) k32s_Parse(k32s* value, const kChar* str);

kFx(kStatus) k64u_Format(k64u value, kChar* buffer, kSize capacity);

kFx(kStatus) k64u_Parse(k64u* value, const kChar* str);

kFx(kStatus) k64s_Format(k64s value, kChar* buffer, kSize capacity);

kFx(kStatus) k64s_Parse(k64s* value, const kChar* str);

kFx(kStatus) kBool_Format(kBool value, kChar* buffer, kSize capacity);

kFx(kStatus) kBool_Parse(kBool* value, const kChar* str);

kFx(kStatus) kSize_Format(kSize value, kChar* buffer, kSize capacity);

kFx(kStatus) kSize_Parse(kSize* value, const kChar* str);

kFx(kStatus) kSSize_Format(kSSize value, kChar* buffer, kSize capacity);

kFx(kStatus) kSSize_Parse(kSSize* value, const kChar* str);

kFx(kStatus) k32f_Format(k32f value, kChar* buffer, kSize capacity);

kFx(kStatus) k32f_Parse(k32f* value, const kChar* str);

kFx(kStatus) k64f_Format(k64f value, kChar* buffer, kSize capacity);

kFx(kStatus) k64f_Parse(k64f* value, const kChar* str);

typedef struct kPoint16s
{
    k16s x;     
    k16s y;     
} kPoint16s;

typedef struct kPoint32s
{
    k32s x;     
    k32s y;     
} kPoint32s; 

typedef struct kPoint32f
{
    k32f x;     
    k32f y;     
} kPoint32f;  

typedef struct kPoint64f
{
    k64f x;     
    k64f y;     
} kPoint64f;

#define kPoint_Init_(POINT, X, Y)     xkPoint_Init_(POINT, X, Y)  

typedef struct kPoint3d16s
{
    k16s x;     
    k16s y;     
    k16s z;     
} kPoint3d16s;

typedef struct kPoint3d32s
{
    k32s x;     
    k32s y;     
    k32s z;     
} kPoint3d32s;  

typedef struct kPoint3d32f
{
    k32f x;     
    k32f y;     
    k32f z;     
} kPoint3d32f; 

typedef struct kPoint3d64f
{
    k64f x;     
    k64f y;     
    k64f z;     
} kPoint3d64f;  

#define kPoint3d_Init_(POINT, X, Y, Z)   xkPoint3d_Init_(POINT, X, Y, Z)

typedef struct kPoint4d16s
{
    k16s x;     
    k16s y;     
    k16s z;     
    k16s w;     
} kPoint4d16s;

#define kPoint4d_Init_(POINT, X, Y, Z, W)   xkPoint4d_Init_(POINT, X, Y, Z, W)

typedef struct kRect16s
{
    k16s x;         
    k16s y;         
    k16s width;     
    k16s height;    
} kRect16s;        

typedef struct kRect32s
{
    k32s x;         
    k32s y;         
    k32s width;     
    k32s height;    
} kRect32s;        

typedef struct kRect32f
{
    k32f x;         
    k32f y;         
    k32f width;     
    k32f height;    
} kRect32f;     

typedef struct kRect64f
{
    k64f x;         
    k64f y;         
    k64f width;     
    k64f height;    
} kRect64f;         

#define kRect_Init_(RECT, X, Y, W, H)    \
    xkRect_Init_(RECT, X, Y, W, H) 

typedef struct kRect3d64f
{
    k64f x;         
    k64f y;         
    k64f z;         
    k64f width;     
    k64f height;    
    k64f depth;     
} kRect3d64f;

#define kRect3d_Init_(RECT, X, Y, Z, W, H, D)    \
    xkRect3d_Init_(RECT, X, Y, Z, W, H, D) 

typedef struct kRotatedRect32s
{
    k32s xc;        
    k32s yc;        
    k32s width;     
    k32s height;    
    k32s angle;     
} kRotatedRect32s;

typedef struct kRotatedRect32f
{
    k32f xc;        
    k32f yc;        
    k32f width;     
    k32f height;    
    k32f angle;     
} kRotatedRect32f;  

#define kRotatedRect_Init_(RECT, XC, YC, W, H, A)   \
        xkRotatedRect_Init_(RECT, XC, YC, W, H, A) 

typedef k32s kPixelFormat; 

#define kPIXEL_FORMAT_NULL              (0)      
#define kPIXEL_FORMAT_8BPP_GREYSCALE    (1)      
#define kPIXEL_FORMAT_8BPP_CFA          (2)      
#define kPIXEL_FORMAT_8BPC_BGRX         (3)      
#define kPIXEL_FORMAT_1BPP_GREYSCALE    (4)      
#define kPIXEL_FORMAT_16BPP_GREYSCALE   (5)      
#define kPIXEL_FORMAT_8BPC_BGR          (6)      

typedef k32s kCfa; 

#define kCFA_NONE            (0)      
#define kCFA_BAYER_BGGR      (1)      
#define kCFA_BAYER_GBRG      (2)      
#define kCFA_BAYER_RGGB      (3)      
#define kCFA_BAYER_GRBG      (4)      

typedef struct kRgb
{
    k8u b;      
    k8u g;      
    k8u r;      
    k8u x;      
} kRgb;

#define kRgb_Init_(RGB, R, G, B)    \
    xkRgb_Init_(RGB, R, G, B) 

typedef struct kArgb
{
    k8u b;      
    k8u g;      
    k8u r;      
    k8u a;      
} kArgb;

#define kArgb_Init_(ARGB, A, R, G, B)   \
    xkArgb_Init_(ARGB, A, R, G, B)

typedef struct kRgb24
{
    k8u b;      
    k8u g;      
    k8u r;      
} kRgb24;

#define kRgb24_Init_(RGB24, R, G, B)   \
    xkRgb24_Init_(RGB24, R, G, B)

typedef struct kMacAddress
{
    kByte address[6];            
} kMacAddress; 

typedef k32s kMemoryAlignment;

#define kMEMORY_ALIGNMENT_8                      (3) 
#define kMEMORY_ALIGNMENT_16                     (4) 
#define kMEMORY_ALIGNMENT_32                     (5) 
#define kMEMORY_ALIGNMENT_64                     (6) 
#define kMEMORY_ALIGNMENT_128                    (7) 
#define kMEMORY_ALIGNMENT_256                    (8) 
#define kMEMORY_ALIGNMENT_512                    (9) 
#define kMEMORY_ALIGNMENT_1024                   (10) 
#define kMEMORY_ALIGNMENT_2048                   (11) 
#define kMEMORY_ALIGNMENT_4096                   (12) 

kInlineFx(kSize) kMemoryAlignment_Size(kMemoryAlignment alignment)
{
    return ((kSize)1 << (kSize)alignment);
}

kFx(kStatus) kMacAddress_Parse(kMacAddress* address, const kChar* text); 

kFx(kStatus) kMacAddress_Format(kMacAddress address, kChar* text, kSize capacity); 

typedef k32s kComparison; 

#define kCOMPARISON_EQ      (0)        
#define kCOMPARISON_NEQ     (1)        
#define kCOMPARISON_LT      (2)        
#define kCOMPARISON_LTE     (3)        
#define kCOMPARISON_GT      (4)        
#define kCOMPARISON_GTE     (5)        


typedef kBool (kCall* kEqualsFx)(const void* item1, const void* item2); 

typedef kSize (kCall* kHashFx)(const void* item); 

typedef kStatus (kCall* kCallbackFx)(kPointer receiver, kPointer sender, void* args); 

typedef struct kCallback
{
    kCallbackFx function;       
    kPointer receiver;          
} kCallback; 

typedef k32s kFileMode;         

#define kFILE_MODE_READ         (0x1)     
#define kFILE_MODE_WRITE        (0x2)     
#define kFILE_MODE_UPDATE       (0x4)     

typedef k32s kSeekOrigin; 

#define kSEEK_ORIGIN_BEGIN      (0)     
#define kSEEK_ORIGIN_CURRENT    (1)     
#define kSEEK_ORIGIN_END        (2)     

typedef k32s kCompressionType; 

#define kCOMPRESSION_TYPE_NULL       (0)     
#define kCOMPRESSION_TYPE_ZSTD       (1)     


typedef k32s kCompressionPreset; 

#define kCOMPRESSION_PRESET_MIN       (-1)      
#define kCOMPRESSION_PRESET_FAST      (-2)      
#define kCOMPRESSION_PRESET_DEFAULT   (-3)      
#define kCOMPRESSION_PRESET_DENSE     (-4)      
#define kCOMPRESSION_PRESET_MAX       (-5)      

typedef k64u kLogOption;

#define kLOG_OPTION_WARNING         (0x1)    
#define kLOG_OPTION_ERROR           (0x2)    
#define kLOG_OPTION_PLATFORM        (0x10)   

#define kCountOf(CARRAY)    \
    (sizeof(CARRAY)/sizeof(CARRAY[0]))  

#define kCast(TYPE, ITEM)       \
    ((TYPE)(ITEM)) 

#if (K_CPP_VERSION >= K_CPP_VERSION_2011)

template <typename T>
static kInline typename std::enable_if<std::is_unsigned<T>::value, T>::type kAbs(const T& v)
{
    return v;
}

template <typename T>
static kInline typename std::enable_if<!std::is_unsigned<T>::value, T>::type kAbs(const T& v)
{
    return (v >= T()) ? v : -v;
}

template <typename T>
static kInline typename std::enable_if<std::is_unsigned<T>::value, T>::type kSign(const T& v)
{
    return v > T();
}

template <typename T>
static kInline typename std::enable_if<!std::is_unsigned<T>::value, T>::type kSign(const T& v)
{
    return (v > T()) - (v < T());
}

template <typename T>
kInlineFx(T) kMin(const T& a, const T& b)
{
    return (a < b) ? a : b;
}

template <typename T>
kInlineFx(T) kMax(const T& a, const T& b)
{
    return (a > b) ? a : b;
}

template <typename T>
kInlineFx(T) kClamp(const T& v, const T& min, const T& max)
{
    return kMin(kMax(v, min), max);
}

template <typename T>
static kInline typename std::enable_if<std::is_unsigned<T>::value, T>::type kDivideFloor(const T& a, const T& b)
{
    return a / b;
}

template <typename T>
static kInline typename std::enable_if<!std::is_unsigned<T>::value, T>::type kDivideFloor(const T& a, const T& b)
{
    return ((kSign(a) * kSign(b)) >= T()) ? a / b : ((a / b) - ((a % b) != T()));
}

template <typename T>
static kInline typename std::enable_if<std::is_unsigned<T>::value, T>::type kDivideCeil(const T& a, const T& b)
{
    return (a / b) + ((a % b) != T());
}

template <typename T>
static kInline typename std::enable_if<!std::is_unsigned<T>::value, T>::type kDivideCeil(const T& a, const T& b)
{
    return ((kSign(a) * kSign(b)) <= T()) ? a / b : ((a / b) + ((a % b) != T()));
}

template <typename T>
kInlineFx(T) kQuantizeFloor(const T& value, const T& granularity)
{
    return kDivideFloor(value, granularity) * granularity;
}

template <typename T>
kInlineFx(T) kQuantizeCeil(const T& value, const T& granularity)
{
    return kDivideCeil(value, granularity) * granularity;
}

template <typename T>
kInlineFx(T) kAdjustFloor(const T& value, const T& min, const T& max, const T& granularity)
{
    typedef typename std::make_unsigned<T>::type U;
    U relativeValue =  (value >= min) ? (U) (value - min) : U();
    U relativeMax = (max >= min) ? (U) (max - min) : U();    
    U quantizedRelativeMax = kQuantizeFloor<U>(relativeMax, granularity);
    U limitedRelativeValue = kMin<U>(relativeValue, quantizedRelativeMax); 

    return (T) kQuantizeFloor<U>(limitedRelativeValue, granularity) + min;
}

template <typename T>
kInlineFx(T) kAdjustCeil(const T& value, const T& min, const T& max, const T& granularity)
{
    typedef typename std::make_unsigned<T>::type U;
    U relativeValue =  (value >= min) ? (U) (value - min) : U();
    U relativeMax = (max >= min) ? (U) (max - min) : U();    
    U quantizedRelativeMax = kQuantizeFloor<U>(relativeMax, granularity);
    U limitedRelativeValue = kMin<U>(relativeValue, quantizedRelativeMax); 

    return (T) kQuantizeCeil<U>(limitedRelativeValue, granularity) + min;
}

#endif

#define kZero(VALUE)           \
    memset(&VALUE, 0, sizeof(VALUE))

kInlineFx(void) kItemCopy(void* dest, const void* src, kSize size)
{
    memcpy(dest, src, size);
}

kInlineFx(void) kItemZero(void* dest, kSize size)
{
    memset(dest, 0, size);
}

typedef k32s kAllocTrait; 

#define kALLOC_TRAIT_FOREIGN                (0x00000001)      
#define kALLOC_TRAIT_SERIAL                 (0x00000002)      
#define kALLOC_TRAIT_NON_ATOMIC             (0x00000004)      
#define kALLOC_TRAIT_CONTEXT                (0x00000008)      
#define kALLOC_TRAIT_CUDA_PINNED            (0x00010000)      
#define kALLOC_TRAIT_CUDA_MANAGED           (0x00020000)      
#define kALLOC_TRAIT_CUDA_DEVICE            (0x01000000)      

kInlineFx(kBool) kAllocTrait_IsForeign(kAllocTrait traits)
{
    return (traits & kALLOC_TRAIT_FOREIGN) != 0;
}

kInlineFx(kBool) kAllocTrait_IsSerial(kAllocTrait traits)
{
    return (traits & kALLOC_TRAIT_SERIAL) != 0;
}

kInlineFx(kBool) kAllocTrait_IsNonAtomic(kAllocTrait traits)
{
    return (traits & kALLOC_TRAIT_NON_ATOMIC) != 0;
}

kInlineFx(kBool) kAllocTrait_SupportsContext(kAllocTrait traits)
{
    return (traits & kALLOC_TRAIT_CONTEXT) != 0;
}

kInlineFx(kBool) kAllocTrait_IsCudaPinned(kAllocTrait traits)
{
    return  (traits & kALLOC_TRAIT_CUDA_PINNED) != 0;
}

kInlineFx(kBool) kAllocTrait_IsCudaManaged(kAllocTrait traits)
{
    return  (traits & kALLOC_TRAIT_CUDA_MANAGED) != 0;
}

kInlineFx(kBool) kAllocTrait_IsCudaDevice(kAllocTrait traits)
{
    return  (traits & kALLOC_TRAIT_CUDA_DEVICE) != 0;
}

kInlineFx(kBool) kAllocTrait_IsCudaDeviceAccessible(kAllocTrait traits)
{
    return  (traits & (kALLOC_TRAIT_CUDA_DEVICE | kALLOC_TRAIT_CUDA_MANAGED | kALLOC_TRAIT_CUDA_PINNED)) != 0;
}

typedef kSize kThreadId; 

kFx(kBool) kThreadId_Compare(kThreadId a, kThreadId b);

typedef k32s kThreadPriorityClass; 

#define kTHREAD_PRIORITY_CLASS_LOW        (-1)    
#define kTHREAD_PRIORITY_CLASS_NORMAL     (0)     
#define kTHREAD_PRIORITY_CLASS_HIGH       (1)     

/*
 * Forward declarations
 */
   
typedef void* kObject;
typedef kObject kType; 
typedef kObject kAlloc; 

#define kTypeName kText64       

typedef k32u kTypeFlags; 

#define kTYPE_FLAGS_CLASS           (0x01)       
#define kTYPE_FLAGS_INTERFACE       (0x02)       
#define kTYPE_FLAGS_VALUE           (0x04)       
#define kTYPE_FLAGS_ENUM            (0x08)       
#define kTYPE_FLAGS_ABSTRACT        (0x20)       
#define kTYPE_FLAGS_ARRAY_VALUE     (0x40)       
#define kTYPE_FLAGS_PRIMITIVE       (0x80)       

typedef kPointer kTypeVersion; 

typedef kStatus (kCall* kFrameworkConstructorFx)(kObject* object, kAlloc allocator);   

typedef struct kMethodInfo
{
    kTypeName methodName;               
    kTypeName functionName;             
    kFunction function;                 
} kMethodInfo; 

typedef struct kFieldInfo
{
    kTypeName name;                     
    kType type;                         
    kSize offset;                       
    kSize count;                        
} kFieldInfo; 

typedef struct kEnumeratorInfo
{
    k32s value;                         
    kTypeName name;                     
    kTypeName displayName;              
} kEnumeratorInfo; 

#define kTypeOf(SYMBOL)     \
    xkTypeOf(SYMBOL)

#define kAssemblyOf(SYMBOL)     \
    xkAssemblyOf(SYMBOL)

#define kStaticOf(SYMBOL)   \
    xkStaticOf(SYMBOL)

#define kDeprecate(SYMBOL) \
    xkDeprecate(#SYMBOL) 

#define kWarn(MESSAGE) \
    xkWarn(MESSAGE) 

/* 
* 
* Type Declaration/Definition Macros, Generation 1. 
* 
* These type declaration/definition macros continue to be supported. However, consider using the Generation 2
* macros (defined below) in new code.
* 
*/

#define kDeclareAssembly(PREFIX, SYMBOL)        \
    xkDeclareAssembly(PREFIX, SYMBOL)       

#define kBeginAssembly(PREFIX, SYMBOL, VERSION, PLATFORM_VERSION)       \
    xkBeginAssembly(PREFIX, SYMBOL, VERSION, PLATFORM_VERSION)

#define kEndAssembly()           \
    xkEndAssembly()  

#define kDeclareValue(PREFIX, SYMBOL, BASE)         \
    xkDeclareValue(PREFIX, SYMBOL, BASE) 

#define kBeginValue(PREFIX, SYMBOL, BASE)       \
    xkBeginValue(PREFIX, SYMBOL, BASE)

#define kEndValue()         \
    xkEndValue() 

#define kDeclareEnum(PREFIX, SYMBOL, BASE)      \
    xkDeclareEnum(PREFIX, SYMBOL, BASE) 

#define kBeginEnum(PREFIX, SYMBOL, BASE)         \
    xkBeginEnum(PREFIX, SYMBOL, BASE) 

#define kEndEnum()           \
    xkEndEnum()

#define kDeclareArrayValue(PREFIX, SYMBOL, BASE)        \
    xkDeclareArrayValue(PREFIX, SYMBOL, BASE) 

#define kBeginArrayValue(PREFIX, SYMBOL, TYPE, BASE)        \
    xkBeginArrayValue(PREFIX, SYMBOL, TYPE, BASE) 

#define kEndArrayValue()        \
    xkEndArrayValue()

#define kDeclareInterface(PREFIX, SYMBOL, BASE)         \
    xkDeclareInterface(PREFIX, SYMBOL, BASE) 

#define kBeginInterface(PREFIX, SYMBOL, BASE)           \
    xkBeginInterface(PREFIX, SYMBOL, BASE) 

#define kEndInterface()         \
    xkEndInterface()  

#define kDeclareFullClass(PREFIX, SYMBOL, BASE)         \
    xkDeclareFullClass(PREFIX, SYMBOL, BASE)  

#define kBeginFullClass(PREFIX, SYMBOL, BASE)       \
    xkBeginFullClass(PREFIX, SYMBOL, BASE) 

#define kEndFullClass()         \
    xkEndFullClass()

#define kDeclareVirtualClass(PREFIX, SYMBOL, BASE)          \
    xkDeclareVirtualClass(PREFIX, SYMBOL, BASE)

#define kBeginVirtualClass(PREFIX, SYMBOL, BASE)        \
    xkBeginVirtualClass(PREFIX, SYMBOL, BASE) 

#define kEndVirtualClass()          \
    xkEndVirtualClass()   

#define kDeclareStaticClass(PREFIX, SYMBOL)         \
    xkDeclareStaticClass(PREFIX, SYMBOL) 

#define kBeginStaticClass(PREFIX, SYMBOL)       \
    xkBeginStaticClass(PREFIX, SYMBOL)  

#define kEndStaticClass()           \
    xkEndStaticClass()

#define kDeclareClass(PREFIX, SYMBOL, BASE)         \
    xkDeclareClass(PREFIX, SYMBOL, BASE)  

#define kBeginClass(PREFIX, SYMBOL, BASE)       \
    xkBeginClass(PREFIX, SYMBOL, BASE) 

#define kEndClass()         \
    xkEndClass()

/* 
* 
* Type Declaration/Definition Macros, Generation 2. 
* 
* These macros are used to declare and define elements of the type system, such 
* as assemblies, classes and values. These macros supersede the Generation 1 macros, 
* defined above. 
* 
*/

#define kDeclareAssemblyEx(PREFIX, SYMBOL) \
    xkDeclareAssemblyEx(PREFIX, SYMBOL)       

#define kBeginAssemblyEx(PREFIX, SYMBOL, VERSION, PLATFORM_VERSION) \
    xkBeginAssemblyEx(PREFIX, SYMBOL, VERSION, PLATFORM_VERSION)

#define kEndAssemblyEx() \
    xkEndAssemblyEx()  

#define kDeclareValueEx(PREFIX, SYMBOL, BASE) \
    xkDeclareValueEx(PREFIX, SYMBOL, BASE) 

#define kBeginValueEx(PREFIX, SYMBOL) \
    xkBeginValueEx(PREFIX, SYMBOL)

#define kEndValueEx() \
    xkEndValueEx() 

#define kDeclareEnumEx(PREFIX, SYMBOL, BASE) \
    xkDeclareEnumEx(PREFIX, SYMBOL, BASE) 

#define kBeginEnumEx(PREFIX, SYMBOL) \
    xkBeginEnumEx(PREFIX, SYMBOL) 

#define kEndEnumEx() \
    xkEndEnumEx()

#define kDeclareArrayValueEx(PREFIX, SYMBOL, BASE) \
    xkDeclareArrayValueEx(PREFIX, SYMBOL, BASE) 

#define kBeginArrayValueEx(PREFIX, SYMBOL, TYPE) \
    xkBeginArrayValueEx(PREFIX, SYMBOL, TYPE) 

#define kEndArrayValueEx() \
    xkEndArrayValueEx()

#define kDeclareInterfaceEx(PREFIX, SYMBOL, BASE) \
    xkDeclareInterfaceEx(PREFIX, SYMBOL, BASE) 

#define kBeginInterfaceEx(PREFIX, SYMBOL) \
    xkBeginInterfaceEx(PREFIX, SYMBOL) 

#define kEndInterfaceEx() \
    xkEndInterfaceEx()  

#define kDeclareFullClassEx(PREFIX, SYMBOL, BASE) \
    xkDeclareFullClassEx(PREFIX, SYMBOL, BASE)  

#define kBeginFullClassEx(PREFIX, SYMBOL) \
    xkBeginFullClassEx(PREFIX, SYMBOL) 

#define kEndFullClassEx() \
    xkEndFullClassEx()

#define kDeclareVirtualClassEx(PREFIX, SYMBOL, BASE) \
    xkDeclareVirtualClassEx(PREFIX, SYMBOL, BASE)

#define kBeginVirtualClassEx(PREFIX, SYMBOL) \
    xkBeginVirtualClassEx(PREFIX, SYMBOL) 

#define kEndVirtualClassEx() \
    xkEndVirtualClassEx()   

#define kDeclareStaticClassEx(PREFIX, SYMBOL) \
    xkDeclareStaticClassEx(PREFIX, SYMBOL) 

#define kBeginStaticClassEx(PREFIX, SYMBOL) \
    xkBeginStaticClassEx(PREFIX, SYMBOL)  

#define kEndStaticClassEx() \
    xkEndStaticClassEx()

#define kDeclareClassEx(PREFIX, SYMBOL, BASE) \
    xkDeclareClassEx(PREFIX, SYMBOL, BASE)  

#define kBeginClassEx(PREFIX, SYMBOL) \
    xkBeginClassEx(PREFIX, SYMBOL) 

#define kEndClassEx() \
    xkEndClassEx()

/* 
* 
* Type Implementation Macros
* 
* These macros are used to provide type-specific details.  They are typically used between 
* type definition begin/end macros (e.g., kBeginClass/kEndClass). 
* 
*/

#define kAddDependency(SYMBOL) \
    xkAddDependency(SYMBOL)    

#define kAddType(SYMBOL) \
    xkAddType(SYMBOL)   

#define kAddPriority(SYMBOL) \
    xkAddPriority(SYMBOL)

#define kAddStatic(SYMBOL) \
    xkAddStatic(SYMBOL)  

#define kAddInterface(SYMBOL, IFACE) \
    xkAddInterface(SYMBOL, IFACE) 

#define kAddFrameworkConstructor(SYMBOL, CTOR) \
    xkAddFrameworkConstructor(SYMBOL, CTOR)  

#define kAddPrivateFrameworkConstructor(SYMBOL, CTOR) \
    xkAddPrivateFrameworkConstructor(SYMBOL, CTOR)  

#define kAddMethod(SYMBOL, METHOD) \
    xkAddMethod(SYMBOL, METHOD)  

#define kAddVMethod(IN_TYPE, FROM_TYPE, METHOD) \
    xkAddVMethod(IN_TYPE, FROM_TYPE, METHOD)   

#define kAddPrivateVMethod(IN_TYPE, FROM_TYPE, METHOD) \
    xkAddPrivateVMethod(IN_TYPE, FROM_TYPE, METHOD)   

#define kAddIVMethod(IN_TYPE, FROM_IFACE, IMETHOD, CMETHOD) \
    xkAddIVMethod(IN_TYPE, FROM_IFACE, IMETHOD, CMETHOD)

#define kAddPrivateIVMethod(IN_TYPE, FROM_IFACE, IMETHOD, CMETHOD) \
    xkAddPrivateIVMethod(IN_TYPE, FROM_IFACE, IMETHOD, CMETHOD)

#define kAddField(VALUE, FIELD_TYPE, FIELD) \
    xkAddField(VALUE, FIELD_TYPE, FIELD)

#define kAddEnumerator \
    xkAddEnumerator

#define kAddVersionEx(TYPE, FORMAT, FORMAT_VER, GUID, WRITE_METHOD, READ_METHOD) \
    xkAddVersionEx(TYPE, FORMAT, FORMAT_VER, GUID, WRITE_METHOD, READ_METHOD)   

#define kAddPrivateVersionEx(TYPE, FORMAT, FORMAT_VER, GUID, WRITE_METHOD, READ_METHOD) \
    xkAddPrivateVersionEx(TYPE, FORMAT, FORMAT_VER, GUID, WRITE_METHOD, READ_METHOD)   

#define kAddAbstractVersionEx(TYPE, FORMAT, FORMAT_VER, GUID) \
    xkAddAbstractVersion(TYPE, FORMAT, FORMAT_VER, GUID)   

#define kAddFlags(TYPE, FLAGS) \
    xkAddFlags(TYPE, FLAGS)     

#define kDefineDebugHints() \
    xkDefineDebugHints()

/* 
* 
* Method Implementation Macros
* 
* These macros are used in the implementation of class methods.
* 
*/

#define kObj(TypeName_T, T_object) \
    TypeName_T##Class* obj K_ATTRIBUTE_UNUSED = xx##TypeName_T##_Cast(T_object, __FILE__, __LINE__)

#define kObjR(TypeName_T, T_object) \
    TypeName_T##Class* obj K_ATTRIBUTE_UNUSED = x##TypeName_T##_CastRaw(T_object)

#define kObjN(TypeName_T, VarName_obj, T_object) \
    TypeName_T##Class* VarName_obj = xx##TypeName_T##_Cast(T_object, __FILE__, __LINE__)
   
#define kObjNR(TypeName_T, VarName_obj, T_object) \
    TypeName_T##Class* VarName_obj = x##TypeName_T##_CastRaw(T_object)

#define kStaticObj(TypeName_T) \
    TypeName_T##Static* sobj = kStaticOf(TypeName_T)

#define kCastClass_(TYPE, OBJECT) \
    xkCastClass_(TYPE, OBJECT)

#define kCastVTable_(TYPE, OBJECT) \
    xkCastVTable_(TYPE, OBJECT)

#define kCastIVTable_(IFACE, OBJECT) \
    xkCastIVTable_(IFACE, OBJECT)

#define kDebugBreak() \
    xkDebugBreak()

#include <kApi/kApiDef.x.h>

#endif