kHxNode.h

Go to the documentation of this file.

#ifndef K_FIRESYNC_HX_NODE_H
#define K_FIRESYNC_HX_NODE_H

#include <kFireSync/kNodeDef.h>

#include <kApi/Data/kString.h>
#include <kApi/Threads/kTimer.h>
#include <kApi/Utils/kDateTime.h>

#include <kFireSync/Health/kHealth.h>
#include <kFireSync/Health/kHealthProbe.h>

#include <kFireSync/Hardware/kHxNode.x.h>

typedef kStatus (kCall* kHxNodeMainFx)();

//typedef kObject kHxNode;      --forward-declared in kFsDef.x.h

kFsFx(kStatus) kHxNode_ConstructPlatformInstance(k32s argc, const kChar** argv);

kInlineFx(kHxNode) kHxNode_PlatformInstance()
{
    return kStaticOf(kHxNode)->platformInstance;
}

kInlineFx(kStatus) kHxNode_FindPlatformInstance(kHxNode* node)
{
    *node = kHxNode_PlatformInstance(); 

    return kIsNull(*node) ? kERROR_NOT_FOUND : kOK; 
}

kInlineFx(kStatus) kHxNode_LoadApp(kHxNode node, kDynamicLib* library)
{
   return xkHxNode_VTable(node)->VLoadApp(node, library);
}

kInlineFx(kBool) kHxNode_HasStorage(kHxNode node)
{
    kObj(kHxNode, node);

    return obj->hasStorage;
}

kInlineFx(kSize) kHxNode_NetInterfaceCount(kHxNode node)
{
    kObj(kHxNode, node);

    return obj->netInterfaceCount;
}

kInlineFx(const kChar*) kHxNode_StoragePath(kHxNode node)
{
    kObj(kHxNode, node);

    return kString_Chars(obj->storagePath);
}

kInlineFx(kStatus) kHxNode_SetMessageAlloc(kHxNode node, kAlloc allocator)
{
    return xkHxNode_VTable(node)->VSetMessageAlloc(node, allocator);
}

kFsFx(kStatus) kHxNode_SetDataHandler(kHxNode node, kCallbackFx function, kPointer receiver); 

kFsFx(kStatus) kHxNode_AddHealthUpdateHandler(kHxNode node, kCallbackFx function, kPointer receiver);

kFsFx(kStatus) kHxNode_RemoveHealthUpdateHandler(kHxNode node, kCallbackFx function, kPointer receiver);

kFsFx(kStatus) kHxNode_AddEnvironUpdateHandler(kHxNode node, kCallbackFx function, kPointer receiver);

kFsFx(kStatus) kHxNode_RemoveEnvironUpdateHandler(kHxNode node, kCallbackFx function, kPointer receiver);

kFsFx(kStatus) kHxNode_StartHealth(kHxNode node, kHealth health, kAlloc alloc);

kFsFx(kStatus) kHxNode_StopHealth(kHxNode node);

kFsFx(kStatus) kHxNode_SetLedMode(kHxNode node, kLed instance, kLedMode mode);

kInlineFx(k64u) kHxNode_MinHealthLogPeriod(kHxNode node)
{
    kObj(kHxNode, node);

    return obj->minHealthLogPeriod; 
}

kInlineFx(kStatus) kHxNode_HealthLogPriority(kHxNode node, kThreadPriorityClass* priorityClass, k32s* priorityOffset)
{
    kObj(kHxNode, node);
    
    *priorityClass = obj->healthLogPriorityClass;
    *priorityOffset = obj->healthLogPriorityOffset;

    return kOK;
}

kInlineFx(kHealth) kHxNode_Health(kHxNode node)
{
    return xkHxNode_VTable(node)->VHealth(node);
}

kInlineFx(void) kHxNode_RequestAppRestart(kHxNode node)
{
    kObj(kHxNode, node);

    obj->restartRequested = kTRUE;
}

kInlineFx(kBool) kHxNode_GetRestartRequest(kHxNode node)
{
    kObj(kHxNode, node);

    return obj->restartRequested;
}

kInlineFx(void) kHxNode_SetLeakedMemory(kHxNode node, kSize amount)
{
    kObj(kHxNode, node);

    kHealthProbe_SetValue(obj->leakProbe, (k64s)amount);
}

kInlineFx(void) kHxNode_AddLeakedMemory(kHxNode node, kSize amount)
{
    kObj(kHxNode, node);

    kHealthProbe_AddValue(obj->leakProbe, (k64s)amount);
}

kInlineFx(kSize) kHxNode_LeakedMemory(kHxNode node)
{
    kObj(kHxNode, node);

    return (kSize) kHealthProbe_Value(obj->leakProbe);
}

kInlineFx(kBool) kHxNode_HasWatchdog(kHxNode node)
{
    kObj(kHxNode, node); 

    return obj->hasWatchdog; 
}

kInlineFx(kStatus) kHxNode_EnableWatchdog(kHxNode node, kBool enable, k64u timeoutPeriod)
{
    return xkHxNode_VTable(node)->VEnableWatchdog(node, enable, timeoutPeriod);
}

kInlineFx(kStatus) kHxNode_UpdateWatchdog(kHxNode node, kRestartReason reason)
{
    return xkHxNode_VTable(node)->VUpdateWatchdog(node, reason);
}

kInlineFx(kStatus) kHxNode_Clear(kHxNode node)
{
    return xkHxNode_VTable(node)->VClear(node);
}

kInlineFx(kStatus) kHxNode_Start(kHxNode node)
{
    return xkHxNode_VTable(node)->VStart(node);
}

kInlineFx(kStatus) kHxNode_Engage(kHxNode node, k64u startTime, k64s startEncoder, kBool maintainPhase)
{
    return xkHxNode_VTable(node)->VEngage(node, startTime, startEncoder, maintainPhase);
}

kInlineFx(kStatus) kHxNode_Disengage(kHxNode node)
{
    return xkHxNode_VTable(node)->VDisengage(node);
} 

kInlineFx(kStatus) kHxNode_Stop(kHxNode node)
{
    return xkHxNode_VTable(node)->VStop(node);
} 

kInlineFx(kStatus) kHxNode_ClearStats(kHxNode node)
{
    return xkHxNode_VTable(node)->VClearStats(node);
} 

kInlineFx(kStatus) kHxNode_WaitForRecoveryEvent(kHxNode node, k64u timeout)
{
    kObj(kHxNode, node);    

    return xkHxNode_VTable(node)->VWaitForRecoveryEvent(node, timeout);
}

kInlineFx(k32u) kHxNode_Id(kHxNode node)
{
    kObj(kHxNode, node); 

    return obj->id; 
}

kInlineFx(kNodeType) kHxNode_NodeType(kHxNode node)
{
    kObj(kHxNode, node); 

    return obj->nodeType;
}

kInlineFx(k32u) kHxNode_NextId(kHxNode node)
{
    kObj(kHxNode, node); 

    return obj->nextId; 
}

kInlineFx(kStatus) kHxNode_SetNextId(kHxNode node, k32u id)
{
    return xkHxNode_VTable(node)->VSetNextId(node, id);
} 

kInlineFx(kTempProbeId) kHxNode_MainTempProbe(kHxNode node)
{
    kObj(kHxNode, node); 

    return obj->mainProbe; 
}

kInlineFx(kStatus) kHxNode_SetMainTempProbe(kHxNode node, kTempProbeId probeId)
{
    kObj(kHxNode, node); 

    obj->mainProbe = probeId;
    
    return kOK; 
}

kInlineFx(kStatus) kHxNode_IpConfig(kHxNode node, kSize index, kIpConfig* config)
{
    kObj(kHxNode, node); 

    *config = obj->ipConfig[index]; 
    
    return kOK; 
}

kInlineFx(kStatus) kHxNode_NextIpConfig(kHxNode node, kSize index, kIpConfig* config)
{
    kObj(kHxNode, node); 

    *config = obj->nextIpConfig[index]; 
    
    return kOK; 
}

kInlineFx(kStatus) kHxNode_SetNextIpConfig(kHxNode node, kSize index, const kIpConfig* config)
{
    return xkHxNode_VTable(node)->VSetNextIpConfig(node, index, config);
} 

kInlineFx(kStatus) kHxNode_WaitForNetworkOnline(kHxNode node)
{
    return xkHxNode_VTable(node)->VWaitForNetworkOnline(node);
} 

kInlineFx(kStatus) kHxNode_DynamicIpConfig(kHxNode node, kSize index, kIpConfig* config)
{
    return xkHxNode_VTable(node)->VDynamicIpConfig(node, index, config);
} 

kInlineFx(kStatus) kHxNode_MacAddress(kHxNode node, kSize index, kMacAddress* address)
{
    kObj(kHxNode, node); 

    *address = obj->macAddress[index]; 

    return kOK; 
} 

kInlineFx(kStatus) kHxNode_SetBootConfig(kHxNode node, const kBootConfig* config)
{
    return xkHxNode_VTable(node)->VSetBootConfig(node, config);
} 

kInlineFx(k64u) kHxNode_PowerSaverTimeout(kHxNode node)
{
    kObj(kHxNode, node); 

    return obj->powerSaverTimeout;
} 

kInlineFx(kStatus) kHxNode_SetPowerSaverTimeout(kHxNode node, k64u timeout)
{
    kObj(kHxNode, node); 

    obj->powerSaverTimeout = timeout; 

    return kOK; 
} 

kInlineFx(k64u) kHxNode_PowerSaverThreshold(kHxNode node)
{
    kObj(kHxNode, node); 

    return obj->powerSaverThreshold;
} 

kInlineFx(kStatus) kHxNode_SetPowerSaverThreshold(kHxNode node, k64u threshold)
{
    kObj(kHxNode, node); 

    obj->powerSaverThreshold = threshold; 

    return kOK; 
} 

kInlineFx(kBool) kHxNode_LightDriverHighPowerEnabled(kHxNode node)
{
    kObj(kHxNode, node); 

    return obj->lightDriverHighPowerEnabled;
} 

kInlineFx(kStatus) kHxNode_EnableLightDriverHighPower(kHxNode node, kBool enabled)
{
    kObj(kHxNode, node); 

    obj->lightDriverHighPowerEnabled = enabled; 

    return xkHxNode_VTable(node)->VEnableLightDriverHighPower(node, enabled);
} 

kInlineFx(kStatus) kHxNode_BootConfig(kHxNode node, kBootConfig* config)
{
    kObj(kHxNode, node);

    *config = obj->bootConfig;

    return kOK;
}

kInlineFx(kNetworkSpeed) kHxNode_NetworkSpeed(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return obj->networkSpeed[index];
}

kInlineFx(kNetworkSpeed) kHxNode_NextNetworkSpeed(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return obj->nextNetworkSpeed[index];
}

kInlineFx(kStatus) kHxNode_SetNextNetworkSpeed(kHxNode node, kSize index, kNetworkSpeed speed)
{
    return xkHxNode_VTable(node)->VSetNextNetworkSpeed(node, index, speed);
} 

kInlineFx(kNetworkSpeed) kHxNode_NetworkSpeedCapabilities(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return obj->networkSpeedCapabilities[index];
}

kInlineFx(kNetworkSpeed) kHxNode_DefaultNetworkSpeed(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return obj->defaultNetworkSpeed[index];
}

kInlineFx(kStatus) kHxNode_SetNetworkTransmitRate(kHxNode node, kSize index, k32u rate)
{
    return xkHxNode_VTable(node)->VSetNetworkTransmitRate(node, index, rate);
}

kInlineFx(k32u) kHxNode_NetworkTransmitRate(kHxNode node, kSize index)
{
    return xkHxNode_VTable(node)->VNetworkTransmitRate(node, index);
} 

kInlineFx(kBool) kHxNode_NetworkTransmitRateSupported(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return obj->networkTransmitRateSupported[index];
}

kInlineFx(kStatus) kHxNode_CommitConfig(kHxNode node)
{
    return xkHxNode_VTable(node)->VCommitConfig(node);
}

kInlineFx(kStatus) kHxNode_ClearFirmware(kHxNode node, kNodeFirmwareType type)
{
    return xkHxNode_VTable(node)->VClearFirmware(node, type);
}

kInlineFx(kStatus) kHxNode_WriteFirmware(kHxNode node, kNodeFirmwareType type, kStream stream, kSize size, kCallbackFx progress, kPointer context)
{
    return xkHxNode_VTable(node)->VWriteFirmware(node, type, stream, size, progress, context);
}

kInlineFx(kStatus) kHxNode_ReloadFirmware(kHxNode node, kNodeFirmwareType type, kStream stream, kSize size)
{
    return xkHxNode_VTable(node)->VReloadFirmware(node, type, stream, size);
}

kFsFx(kStatus) kHxNode_Info(kHxNode node, kNodeInfo* info);

kInlineFx(kBool) kHxNode_IsRescue(kHxNode node)
{
    kObj(kHxNode, node);

    return (obj->bootMode == kBOOT_MODE_RESCUE) || (obj->bootMode == kBOOT_MODE_FALLBACK);
} 

kInlineFx(kBool) kHxNode_IsVirtual(kHxNode node)
{    
    kObj(kHxNode, node);

    return (obj->controllerType == kCONTROLLER_TYPE_VIRTUAL); 
}

kInlineFx(kSize) kHxNode_ProcessorCount(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->cpuCount;
}

kInlineFx(kStatus) kHxNode_LogEx(kHxNode node, kLogOption options, const kChar* source, const kChar* message)
{
    return xkHxNode_VTable(node)->VLogEx(node, options, source, message);
}

kInlineFx(kStatus) kHxNode_Log(kHxNode node, const kChar* message)
{
    return kHxNode_LogEx(node, 0, "", message);
}

kFsFx(kStatus) kHxNode_ReadLogItems(kHxNode node, kArrayList logItems);

kFsFx(kStatus) kHxNode_GetLogItems(kHxNode node, kArrayList logItems);

kInlineFx(kStatus) kHxNode_GetCrashLog(kHxNode node, kString* crashLog, kAlloc allocator)
{
    return xkHxNode_VTable(node)->VGetCrashLog(node, crashLog, allocator);
} 

kInlineFx(kStatus) kHxNode_ClearCrashLog(kHxNode node)
{
    return xkHxNode_VTable(node)->VClearCrashLog(node);
} 

kInlineFx(kStatus) kHxNode_SetCrashLogAppInfo(kHxNode node, kVersion version, k32u nodeId)
{
    return xkHxNode_VTable(node)->VSetCrashLogAppInfo(node, version, nodeId);
}

kInlineFx(kStatus) kHxNode_Stats(kHxNode node, kNodeStats* stats)
{
    return xkHxNode_VTable(node)->VStats(node, stats);
} 

kInlineFx(kBool) kHxNode_PlLoaded(kHxNode node)
{    
    kObj(kHxNode, node);

    return xkHxNode_VTable(node)->VPlLoaded(node);
}

kInlineFx(kVersion) kHxNode_PlVersion(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->mainPlVersion;
}

kInlineFx(k32u) kHxNode_PlConfig(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->mainPlConfig;
}

kInlineFx(kBool) kHxNode_Pl2Loaded(kHxNode node)
{    
    kObj(kHxNode, node);

    return xkHxNode_VTable(node)->VPl2Loaded(node);
}

kInlineFx(kVersion) kHxNode_Pl2Version(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->secondaryPlVersion;
}

kInlineFx(k32u) kHxNode_Pl2Config(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->secondaryPlConfig;
}

kInlineFx(kDaughterboardModel) kHxNode_DaughterboardModel(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->daughterboardModel;
}

kInlineFx(kStatus) kHxNode_ReadMemory(kHxNode node, kNodeMemorySpace space, k64u offset, kSize length, void* data)
{
    return xkHxNode_VTable(node)->VReadMemory(node, space, offset, length, data);
} 

kInlineFx(kStatus) kHxNode_WriteMemory(kHxNode node, kNodeMemorySpace space, k64u offset, kSize length, const void* data)
{
    return xkHxNode_VTable(node)->VWriteMemory(node, space, offset, length, data);
} 

kInlineFx(kStatus) kHxNode_ReadRegisters(kHxNode node, kRegisterModule moduleType, kSize moduleIndex, kArrayList registers)
{
    return xkHxNode_VTable(node)->VReadRegisters(node, moduleType, moduleIndex, registers);
} 

kInlineFx(kStatus) kHxNode_ReadRegisterOverrides(kHxNode node, kRegisterModule moduleType, kArrayList registers)
{
    return xkHxNode_VTable(node)->VReadRegisterOverrides(node, moduleType, registers);
} 

kInlineFx(kStatus) kHxNode_WriteRegisterOverrides(kHxNode node, kRegisterModule moduleType, kArrayList registers)
{
    return xkHxNode_VTable(node)->VWriteRegisterOverrides(node, moduleType, registers);
} 

kInlineFx(kStatus) kHxNode_I2cRead(kHxNode node, k32u deviceId, k32u address, kByte* data, kSize size)
{
    return xkHxNode_VTable(node)->VI2cRead(node, deviceId, address, data, size);
} 

kInlineFx(kStatus) kHxNode_I2cWrite(kHxNode node, k32u deviceId, k32u address, const kByte* data, kSize size)
{
    return xkHxNode_VTable(node)->VI2cWrite(node, deviceId, address, data, size);
} 

kInlineFx(kStatus) kHxNode_BeginSpi(kHxNode node, kSpiDeviceType deviceType)
{
    return xkHxNode_VTable(node)->VBeginSpi(node, deviceType);
}

kInlineFx(kStatus) kHxNode_EndSpi(kHxNode node)
{
    return xkHxNode_VTable(node)->VEndSpi(node);
}

kInlineFx(kStatus) kHxNode_SpiRead(kHxNode node, kByte* opCode, kSize opSize, kByte* data, kSize dataSize)
{
    return xkHxNode_VTable(node)->VSpiRead(node, opCode, opSize, data, dataSize);
}

kInlineFx(kStatus) kHxNode_SpiWrite(kHxNode node, kByte* opCode, kSize opSize, kByte* data, kSize dataSize)
{
    return xkHxNode_VTable(node)->VSpiWrite(node, opCode, opSize, data, dataSize);
}

kInlineFx(kStatus) kHxNode_SetTempControl(kHxNode node, const kTempControlEx* temp)
{
    return xkHxNode_VTable(node)->VSetTempControl(node, temp);
} 

kInlineFx(kStatus) kHxNode_TempControl(kHxNode node, kTempControlEx* temp)
{
    return xkHxNode_VTable(node)->VTempControl(node, temp);
} 

kInlineFx(kSize) kHxNode_EventCount(kHxNode node)
{
    kObj(kHxNode, node);

    return kArrayList_Count(obj->eventManagers);
}

kInlineFx(kHxEvent) kHxNode_EventAt(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return kArrayList_AsT(obj->eventManagers, index, kHxEvent);
}

kInlineFx(kSize) kHxNode_CameraCount(kHxNode node)
{
    kObj(kHxNode, node);

    return kArrayList_Count(obj->cameras);
}

kInlineFx(kHxCamera) kHxNode_CameraAt(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return kArrayList_AsT(obj->cameras, index, kHxCamera);
}

kInlineFx(kSize) kHxNode_LightCount(kHxNode node)
{
    kObj(kHxNode, node);

    return kArrayList_Count(obj->lights);
}

kInlineFx(kHxLight) kHxNode_LightAt(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return kArrayList_AsT(obj->lights, index, kHxLight);
}

kInlineFx(kSize) kHxNode_DigitalCount(kHxNode node)
{
    kObj(kHxNode, node);

    return kArrayList_Count(obj->digitalOutputs);
}

kInlineFx(kHxDigitalOut) kHxNode_DigitalAt(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return kArrayList_AsT(obj->digitalOutputs, index, kHxDigitalOut);
}

kInlineFx(kSize) kHxNode_AnalogCount(kHxNode node)
{
    kObj(kHxNode, node);

    return kArrayList_Count(obj->analogOutputs);
}

kInlineFx(kHxAnalogOut) kHxNode_AnalogAt(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return kArrayList_AsT(obj->analogOutputs, index, kHxAnalogOut);
}

kInlineFx(kSize) kHxNode_SerialCount(kHxNode node)
{
    kObj(kHxNode, node);

    return kArrayList_Count(obj->serialOutputs);
}

kInlineFx(kHxSerialOut) kHxNode_SerialAt(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return kArrayList_AsT(obj->serialOutputs, index, kHxSerialOut);
}

kInlineFx(kSize) kHxNode_ProjectorCount(kHxNode node)
{
    kObj(kHxNode, node);

    return kArrayList_Count(obj->projectors);
}

kInlineFx(kHxProjector) kHxNode_ProjectorAt(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return kArrayList_AsT(obj->projectors, index, kHxProjector);
}

kInlineFx(kSize) kHxNode_IoTestCount(kHxNode node)
{
    kObj(kHxNode, node);

    return kArrayList_Count(obj->ioTests);
}

kInlineFx(kHxIoTest) kHxNode_IoTestAt(kHxNode node, kSize index)
{
    kObj(kHxNode, node);

    return kArrayList_AsT(obj->ioTests, index, kHxIoTest);
}

kInlineFx(kHxEncoder) kHxNode_Encoder(kHxNode node)
{
    kObj(kHxNode, node);

    return obj->encoder;
}

kInlineFx(kHxGpio) kHxNode_Gpio(kHxNode node)
{
    kObj(kHxNode, node);

    return obj->gpio;
}

kInlineFx(kHxTestJig) kHxNode_TestJig(kHxNode node)
{
    kObj(kHxNode, node);

    return obj->testJig;
}

kInlineFx(kStatus) kHxNode_EnableLed(kHxNode node, kLed instance, kBool enabled)
{
    return xkHxNode_VTable(node)->VEnableLed(node, instance, enabled);
} 

kInlineFx(kControllerType) kHxNode_ControllerType(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->controllerType;
}

kInlineFx(k64s) kHxNode_EncoderCounter(kHxNode node)
{
    return xkHxNode_VTable(node)->VEncoderCounter(node);
} 

kInlineFx(k64u) kHxNode_TimeCounter(kHxNode node)
{
    return xkHxNode_VTable(node)->VTimeCounter(node);
} 

kInlineFx(kSize) kHxNode_LocalDigitalInputCount(kHxNode node)
{    
    //currently hardcoded, based on PL documentation; should we read this from somewhere?
    return 2; 
}

kInlineFx(kSize) kHxNode_NetworkDigitalInputCount(kHxNode node)
{
    //currently hardcoded, based on PL documentation; should we read this from somewhere?
    return 4; 
}

kInlineFx(kBool) kHxNode_HasPeltier(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->hasPeltier;
}

kInlineFx(kBool) kHxNode_HasExternalTempProbe(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->hasExternalTempProbe;
}

kInlineFx(kSize) kHxNode_FanCount(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->fanCount;
}

kInlineFx(k64u) kHxNode_CameraDataBandwidth(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->cameraDataBandwidth; 
}

kInlineFx(kStatus) kHxNode_SetSyncSource(kHxNode node, kSyncSource source)
{
    return xkHxNode_VTable(node)->VSetSyncSource(node, source);
} 

kInlineFx(kSyncSource) kHxNode_SyncSource(kHxNode node)
{    
    kObj(kHxNode, node);

    return obj->syncSource; 
}

kInlineFx(kStatus) kHxNode_SetEventHandler(kHxNode node, kCallbackFx function, kPointer receiver, kAlloc eventAlloc)
{
    return xkHxNode_VTable(node)->VSetEventHandler(node, function, receiver, eventAlloc);
} 

kInlineFx(kStatus) kHxNode_SetLightDriverControl(kHxNode node, k64u key, kSize index, kBool enabled)
{
    return xkHxNode_VTable(node)->VSetLightDriverControl(node, key, index, enabled);
} 

kInlineFx(kStatus) kHxNode_GetLightDriverControl(kHxNode node, k64u key, kSize index, kBool* enabled)
{
    return xkHxNode_VTable(node)->VGetLightDriverControl(node, key, index, enabled);
} 

kInlineFx(kStatus) kHxNode_SetLightDriverPower(kHxNode node, k64u key, kSize index, k32u power, kBool commit)
{
    return xkHxNode_VTable(node)->VSetLightDriverPower(node, key, index, power, commit);
} 

kInlineFx(kStatus) kHxNode_GetLightDriverPower(kHxNode node, k64u key, kSize index, k32u* power)
{
    return xkHxNode_VTable(node)->VGetLightDriverPower(node, key, index, power);
} 

kInlineFx(kStatus) kHxNode_SetLightDriverCurrentLimit(kHxNode node, k64u key, kSize index, k32u currentLimit, kBool commit)
{
    return xkHxNode_VTable(node)->VSetLightDriverCurrentLimit(node, key, index, currentLimit, commit);
} 

kInlineFx(kStatus) kHxNode_GetLightDriverCurrentLimit(kHxNode node, k64u key, kSize index, k32u* currentLimit)
{
    return xkHxNode_VTable(node)->VGetLightDriverCurrentLimit(node, key, index, currentLimit);
} 

kInlineFx(kStatus) kHxNode_GetLightDriverRemainingSlotCount(kHxNode node, k64u key, kSize index, kSize* remainingCount)
{
    return xkHxNode_VTable(node)->VGetLightDriverRemainingSlotCount(node, key, index, remainingCount);
} 

kInlineFx(kStatus) kHxNode_SetLightDriverInfo(kHxNode node, k64u key, kSize index, kLightModel model, kVersion revision, k32u deviceId)
{
    return xkHxNode_VTable(node)->VSetLightDriverInfo(node, key, index, model, revision, deviceId);
} 

kInlineFx(kStatus) kHxNode_GetLightDriverInfo(kHxNode node, k64u key, kSize index, kLightModel* model, kVersion* revision, k32u* deviceId)
{
    return xkHxNode_VTable(node)->VGetLightDriverInfo(node, key, index, model, revision, deviceId);
} 

kInlineFx(kStatus) kHxNode_SetLightDriverCalibration(kHxNode node, kSize index, k64u key, kDataTree ldCal, kBool commit)
{
    return xkHxNode_VTable(node)->VSetLightDriverCalibration(node, index, key, ldCal, commit);
} 

kInlineFx(kStatus) kHxNode_GetLightDriverCalibration(kHxNode node, kSize index, k64u key, kDataTree* ldCal, kAlloc alloc)
{
    return xkHxNode_VTable(node)->VGetLightDriverCalibration(node, index, key, ldCal, alloc);
} 

kInlineFx(kStatus) kHxNode_ReadLightDriverTemperature(kHxNode node, kSize index, k64u key, k32s* temperature)
{
    return xkHxNode_VTable(node)->VReadLightDriverTemperature(node, index, key, temperature);
} 

kFsFx(kStatus) kHxNode_SetDateTime(kHxNode node, kDateTime dateTime);

kFsFx(kDateTime) kHxNode_DateTime(kHxNode node);

kInlineFx(kStatus) kHxNode_IncrementInputCounter(kHxNode node)
{    
    kObj(kHxNode, node);

    kAtomic32s_Increment(&obj->inputCounter);

    return kOK;
}

kInlineFx(kStatus) kHxNode_InputCounter(kHxNode node)
{    
    kObj(kHxNode, node);

    return kAtomic32s_Get(&obj->inputCounter);
}

#endif