kType.h

Go to the documentation of this file.

#include <kApi/kApiDef.h>   //--inclusion order controlled by kApiDef

#ifndef K_API_TYPE_H
#define K_API_TYPE_H

#include <kApi/kType.x.h>

//typedef kObject kType;   --forward-declared in kApiDef.x.h

kInlineFx(kAssembly) kType_Assembly(kType type)
{
    xkTypeObj(type); 

    return obj->assembly; 
}
kInlineFx(const kChar*) kType_Name(kType type)
{
    xkTypeObj(type); 
    
    return obj->name; 
}

kInlineFx(kBool) kType_Is(kType type, kType other)
{ 
    return (type == other) || 
           kType_Extends(type, other) || 
           kType_Implements(type, other); 
}

kInlineFx(kBool) kType_IsValue(kType type)
{ 
    xkTypeObj(type); 

    return (obj->flags & kTYPE_FLAGS_VALUE) != 0; 
}

kInlineFx(kBool) kType_IsClass(kType type) 
{ 
    xkTypeObj(type); 

    return (obj->flags & kTYPE_FLAGS_CLASS) != 0; 
}

kInlineFx(kBool) kType_IsInterface(kType type)
{ 
    xkTypeObj(type); 

    return (obj->flags & kTYPE_FLAGS_INTERFACE) != 0; 
}

kInlineFx(kBool) kType_IsReference(kType type)
{ 
    xkTypeObj(type); 

    return (obj->flags & (kTYPE_FLAGS_INTERFACE | kTYPE_FLAGS_CLASS)) != 0; 
}

kInlineFx(kBool) kType_IsAbstract(kType type)
{ 
    xkTypeObj(type); 

    return (obj->flags & kTYPE_FLAGS_ABSTRACT) != 0; 
}

kInlineFx(kBool) kType_IsEnum(kType type)
{
    xkTypeObj(type); 

    return (obj->flags & kTYPE_FLAGS_ENUM) != 0; 
}

kInlineFx(kBool) kType_IsArrayValue(kType type)
{ 
    xkTypeObj(type); 

    return (obj->flags & kTYPE_FLAGS_ARRAY_VALUE) != 0; 
}

kInlineFx(kBool) kType_IsPrimitive(kType type)
{ 
    xkTypeObj(type); 

    return (obj->flags & kTYPE_FLAGS_PRIMITIVE) != 0;
}

kInlineFx(kBool) kType_IsPacked(kType type) 
{ 
    xkTypeObj(type); 

    return (obj->flags & xkTYPE_FLAGS_PACKED) != 0; 
}

kInlineFx(kBool) kType_Implements(kType type, kType interfaceType)
{ 
    return kType_IVTable(type, interfaceType) != kNULL; 
}

kInlineFx(kBool) kType_Extends(kType type, kType baseType)
{
    xkTypeObj(type); 

    return obj->bases[0] == baseType || 
           obj->bases[1] == baseType ||
           obj->bases[2] == baseType ||
           obj->bases[3] == baseType; 
}

kInlineFx(kType) kType_Base(kType type)
{ 
    xkTypeObj(type); 

    return obj->bases[0]; 
}

kInlineFx(kSize) kType_InterfaceCount(kType type)
{
    xkTypeObj(type); 

    return obj->interfaceCount; 
}

kInlineFx(kType) kType_InterfaceAt(kType type, kSize index)
{
    xkTypeObj(type); 

    kAssert(index < obj->interfaceCount);

    return obj->interfaces[index].type;
}

kInlineFx(kSize) kType_Size(kType type)
{ 
    xkTypeObj(type); 

    return obj->size; 
}

kInlineFx(kSize) kType_InnerSize(kType type) 
{ 
    xkTypeObj(type); 

    return obj->innerSize; 
}

kInlineFx(kSize) kType_StaticSize(kType type)
{
    xkTypeObj(type);

    return obj->staticSize;
}

kInlineFx(kFunction*) kType_VTable(kType type)
{ 
    xkTypeObj(type); 

    return obj->vTable; 
}

#define kType_VTableT(kType_type, T) \
    kCast(T##VTable*, xkType_VTableT(kType_type, kTypeOf(T)))

kInlineFx(kFunction*) kType_IVTable(kType type, kType interfaceType)
{
    xkTypeObj(type); 

    if      (obj->interfaces[0].type == interfaceType)      return obj->interfaces[0].iTable; 
    else if (obj->interfaces[1].type == interfaceType)      return obj->interfaces[1].iTable; 
    else if (obj->interfaces[2].type == interfaceType)      return obj->interfaces[2].iTable; 
    else if (obj->interfaces[3].type == interfaceType)      return obj->interfaces[3].iTable; 
    else                                                    return kNULL;  
}

kInlineFx(void*) kType_Static(kType type)
{ 
    xkTypeObj(type); 

    return obj->staticData; 
}

kInlineFx(kBool) kType_StaticInitialized(kType type)
{
    kObjR(kType, type); 

    return !kIsNull(obj->staticInitialized) && *obj->staticInitialized; 
}

kInlineFx(kSize) kType_MethodCount(kType type)
{
    xkTypeObj(type); 

    return obj->cMethodCount; 
}

kInlineFx(const kMethodInfo*) kType_MethodInfoAt(kType type, kSize index)
{
    xkTypeObj(type); 

    kAssert(index < obj->cMethodCount);

    return &obj->cMethodInfo[index]; 
}

kFx(kStatus) kType_FindMethodInfo(kType type, const kChar* name, const kMethodInfo** info);

kInlineFx(kSize) kType_VMethodCount(kType type)
{
    xkTypeObj(type); 

    return obj->vMethodCount; 
}

kInlineFx(const kMethodInfo*) kType_VMethodInfoAt(kType type, kSize index)
{
    xkTypeObj(type); 

    kAssert(index < obj->vMethodCount); 
    
    return &obj->vMethodInfo[index]; 
}

kInlineFx(kSize) kType_IMethodCount(kType type, kType interfaceType)
{
    xkTypeObj(type); 
    xkInterfaceInfo* info = xkType_InterfaceInfo(obj, interfaceType);   

    return kIsNull(info) ? 0 : info->iMethodCount; 
}

kInlineFx(const kMethodInfo*) kType_IMethodInfoAt(kType type, kType interfaceType, kSize index)
{
    xkTypeObj(type); 
    xkInterfaceInfo* info = xkType_InterfaceInfo(obj, interfaceType);   

    kAssert(index < info->iMethodCount);

    return kIsNull(info) ? kNULL : &info->iMethodInfo[index]; 
}

kInlineFx(kSize) kType_FieldCount(kType type)
{
    xkTypeObj(type); 

    return obj->fieldCount; 
}

kInlineFx(const kFieldInfo*) kType_FieldInfoAt(kType type, kSize index)
{
    xkTypeObj(type); 

    kAssert(index < obj->fieldCount);

    return &obj->fieldInfo[index];
}

kInlineFx(kSize) kType_EnumeratorCount(kType type)
{
    xkTypeObj(type); 

    return obj->enumeratorCount; 
}

kInlineFx(const kEnumeratorInfo*) kType_EnumeratorInfoAt(kType type, kSize index)
{
    xkTypeObj(type); 

    kAssert(index < obj->enumeratorCount);

    return &obj->enumeratorInfo[index]; 
}

kFx(kStatus) kType_FindEnumeratorInfo(kType type, k32s value, const kEnumeratorInfo** info);

kFx(kStatus) kType_FormatEnumerator(kType type, k32s value, kChar* displayName, kSize capacity);

kFx(kStatus) kType_ParseEnumerator(kType type, k32s* value, const kChar* displayName);

kInlineFx(kSize) kType_VersionCount(kType type)
{
    xkTypeObj(type); 

    return obj->versionCount; 
}

kInlineFx(kTypeVersion) kType_VersionAt(kType type, kSize index)
{
    xkTypeObj(type); 

    kAssert(index < obj->versionCount);

    return &obj->versionInfo[index]; 
}

kInlineFx(const kChar*) kType_VersionGuid(kType type, kPointer version) 
{ 
    return kCast(kTypeVersionInfo*, version)->guid; 
}

kInlineFx(kFunction) kType_VersionSerializeFx(kType type, kTypeVersion version)
{
    return kCast(kTypeVersionInfo*, version)->serialize;
}

kInlineFx(kFunction) kType_VersionDeserializeFx(kType type, kTypeVersion version)
{
    return kCast(kTypeVersionInfo*, version)->deserialize;
}

kInlineFx(const kChar*) kType_VersionFormat(kType type, kTypeVersion version)
{
    return kCast(kTypeVersionInfo*, version)->format;
}

kInlineFx(kVersion) kType_VersionFormatVersion(kType type, kTypeVersion version)
{
    return kCast(kTypeVersionInfo*, version)->formatVersion;
}

#endif