////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: Parameter Parser V5.5.1 (2411131018)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afmonitorelements.cpp
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "afmonitorelements.h"
#include "parametersetmanager.h"

AFMONITORELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixIirFltrCfgType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        ParameterUtils::DoubleToString((double)numOfSamples, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "coeffNumerator") == 0)
    {
        ParameterUtils::DoubleToString((double)coeffNumerator, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "coeffDenominator") == 0)
    {
        ParameterUtils::DoubleToString((double)coeffDenominator, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixIirFltrCfgType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numOfSamples = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "coeffNumerator") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            coeffNumerator = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "coeffDenominator") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            coeffDenominator = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixIirFltrCfgType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // enable
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Int32, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)enable, 0));
    }

    // numOfSamples
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("numOfSamples", ParameterParserDataType::Int32, (double)numOfSamples, 0));
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)numOfSamples, 0));
    }

    // coeffNumerator
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("coeffNumerator", ParameterParserDataType::Float, (double)coeffNumerator));
    }
    else if (PARAMETER_STRCMP(__name, "coeffNumerator") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)coeffNumerator));
    }

    // coeffDenominator
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("coeffDenominator", ParameterParserDataType::Float, (double)coeffDenominator));
    }
    else if (PARAMETER_STRCMP(__name, "coeffDenominator") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)coeffDenominator));
    }

    return __result;
}

bool chromatixMvavgFltrCfgType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        ParameterUtils::DoubleToString((double)numOfSamples, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixMvavgFltrCfgType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numOfSamples = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixMvavgFltrCfgType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // enable
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Int32, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)enable, 0));
    }

    // numOfSamples
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("numOfSamples", ParameterParserDataType::Int32, (double)numOfSamples, 0));
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)numOfSamples, 0));
    }

    return __result;
}

bool chromatixMedianFltrCfgType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        ParameterUtils::DoubleToString((double)numOfSamples, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixMedianFltrCfgType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numOfSamples = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixMedianFltrCfgType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // enable
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Int32, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)enable, 0));
    }

    // numOfSamples
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("numOfSamples", ParameterParserDataType::Int32, (double)numOfSamples, 0));
    }
    else if (PARAMETER_STRCMP(__name, "numOfSamples") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)numOfSamples, 0));
    }

    return __result;
}

bool chromatixSensProfileType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "triggerThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)triggerThreshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "consecutiveCountThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)consecutiveCountThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameToArmed") == 0)
    {
        ParameterUtils::DoubleToString((double)frameToArmed, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "highCountThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)highCountThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lowCountThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)lowCountThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "medianFltrCfg") == 0)
    {
        __result = medianFltrCfg.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "mvavgFltrCfg") == 0)
    {
        __result = mvavgFltrCfg.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "IIRFltrCfg") == 0)
    {
        __result = IIRFltrCfg.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixSensProfileType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "triggerThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            triggerThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "consecutiveCountThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            consecutiveCountThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameToArmed") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameToArmed = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "highCountThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            highCountThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lowCountThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lowCountThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "medianFltrCfg") == 0)
    {
        __result = medianFltrCfg.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "mvavgFltrCfg") == 0)
    {
        __result = mvavgFltrCfg.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "IIRFltrCfg") == 0)
    {
        __result = IIRFltrCfg.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixSensProfileType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // triggerThreshold
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("triggerThreshold", ParameterParserDataType::Float, (double)triggerThreshold));
    }
    else if (PARAMETER_STRCMP(__name, "triggerThreshold") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)triggerThreshold));
    }

    // consecutiveCountThreshold
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("consecutiveCountThreshold", ParameterParserDataType::Int32, (double)consecutiveCountThreshold, 0));
    }
    else if (PARAMETER_STRCMP(__name, "consecutiveCountThreshold") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)consecutiveCountThreshold, 0));
    }

    // frameToArmed
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("frameToArmed", ParameterParserDataType::Int32, (double)frameToArmed, 0));
    }
    else if (PARAMETER_STRCMP(__name, "frameToArmed") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)frameToArmed, 0));
    }

    // highCountThreshold
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("highCountThreshold", ParameterParserDataType::Int32, (double)highCountThreshold, 0));
    }
    else if (PARAMETER_STRCMP(__name, "highCountThreshold") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)highCountThreshold, 0));
    }

    // lowCountThreshold
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("lowCountThreshold", ParameterParserDataType::Int32, (double)lowCountThreshold, 0));
    }
    else if (PARAMETER_STRCMP(__name, "lowCountThreshold") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)lowCountThreshold, 0));
    }

    // medianFltrCfg
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("medianFltrCfg", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "medianFltrCfg") == 0)
    {
        __result = medianFltrCfg.GetInfo(&__path[__pos], __info);
    }

    // mvavgFltrCfg
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("mvavgFltrCfg", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "mvavgFltrCfg") == 0)
    {
        __result = mvavgFltrCfg.GetInfo(&__path[__pos], __info);
    }

    // IIRFltrCfg
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("IIRFltrCfg", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "IIRFltrCfg") == 0)
    {
        __result = IIRFltrCfg.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool chromatixAbsoluteModeCfgType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "baseline") == 0)
    {
        ParameterUtils::DoubleToString((double)baseline, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixAbsoluteModeCfgType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "baseline") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            baseline = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixAbsoluteModeCfgType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // enable
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Int32, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)enable, 0));
    }

    // baseline
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("baseline", ParameterParserDataType::Float, (double)baseline));
    }
    else if (PARAMETER_STRCMP(__name, "baseline") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Float, (double)baseline));
    }

    return __result;
}

bool chromatixValueMonitorType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "VMSetType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)VMSetType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "detectionType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)detectionType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "VMInitState") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)VMInitState, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "absoluteModeCfg") == 0)
    {
        __result = absoluteModeCfg.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileLow") == 0)
    {
        __result = sensProfileLow.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileMed") == 0)
    {
        __result = sensProfileMed.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileHigh") == 0)
    {
        __result = sensProfileHigh.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixValueMonitorType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "VMSetType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            VMSetType = (chromatixVMSetTypeEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "detectionType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            detectionType = (chromatixDetectorTypeEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "VMInitState") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            VMInitState = (chromatixVMStateEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "absoluteModeCfg") == 0)
    {
        __result = absoluteModeCfg.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileLow") == 0)
    {
        __result = sensProfileLow.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileMed") == 0)
    {
        __result = sensProfileMed.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileHigh") == 0)
    {
        __result = sensProfileHigh.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixValueMonitorType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // VMSetType
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("VMSetType", ParameterParserDataType::Enum, (double)(UINT32)VMSetType, 0));
    }
    else if (PARAMETER_STRCMP(__name, "VMSetType") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)VMSetType, 0));
    }

    // detectionType
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("detectionType", ParameterParserDataType::Enum, (double)(UINT32)detectionType, 0));
    }
    else if (PARAMETER_STRCMP(__name, "detectionType") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)detectionType, 0));
    }

    // VMInitState
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("VMInitState", ParameterParserDataType::Enum, (double)(UINT32)VMInitState, 0));
    }
    else if (PARAMETER_STRCMP(__name, "VMInitState") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)VMInitState, 0));
    }

    // absoluteModeCfg
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("absoluteModeCfg", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "absoluteModeCfg") == 0)
    {
        __result = absoluteModeCfg.GetInfo(&__path[__pos], __info);
    }

    // sensProfileLow
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensProfileLow", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileLow") == 0)
    {
        __result = sensProfileLow.GetInfo(&__path[__pos], __info);
    }

    // sensProfileMed
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensProfileMed", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileMed") == 0)
    {
        __result = sensProfileMed.GetInfo(&__path[__pos], __info);
    }

    // sensProfileHigh
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensProfileHigh", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileHigh") == 0)
    {
        __result = sensProfileHigh.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool chromatixValueMonitorBankType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "valueMonitor") == 0)
    {
        if (__index < valueMonitorCount)
        {
            __result = valueMonitor[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixValueMonitorBankType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "valueMonitor") == 0)
    {
        if (__index < valueMonitorCount)
        {
            __result = valueMonitor[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixValueMonitorBankType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // valueMonitor
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("valueMonitor", ParameterParserDataType::Structure, true, false, valueMonitorCount));
    }
    else if (PARAMETER_STRCMP(__name, "valueMonitor") == 0)
    {
        if (__index < valueMonitorCount)
        {
            __result = valueMonitor[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, valueMonitorCount));
        }
    }

    return __result;
}

bool sensitivityModifierArr::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "roiBasedSensitivityModifier") == 0)
    {
        if (__index < roiBasedSensitivityModifierCount)
        {
            __result = roiBasedSensitivityModifier[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "zoomBasedSensitivityModifier") == 0)
    {
        if (__index < zoomBasedSensitivityModifierCount)
        {
            __result = zoomBasedSensitivityModifier[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "gainBasedSensitivityModifier") == 0)
    {
        if (__index < gainBasedSensitivityModifierCount)
        {
            __result = gainBasedSensitivityModifier[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool sensitivityModifierArr::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "roiBasedSensitivityModifier") == 0)
    {
        if (__index < roiBasedSensitivityModifierCount)
        {
            __result = roiBasedSensitivityModifier[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "zoomBasedSensitivityModifier") == 0)
    {
        if (__index < zoomBasedSensitivityModifierCount)
        {
            __result = zoomBasedSensitivityModifier[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "gainBasedSensitivityModifier") == 0)
    {
        if (__index < gainBasedSensitivityModifierCount)
        {
            __result = gainBasedSensitivityModifier[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool sensitivityModifierArr::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // roiBasedSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("roiBasedSensitivityModifier", ParameterParserDataType::Structure, true, false, roiBasedSensitivityModifierCount));
    }
    else if (PARAMETER_STRCMP(__name, "roiBasedSensitivityModifier") == 0)
    {
        if (__index < roiBasedSensitivityModifierCount)
        {
            __result = roiBasedSensitivityModifier[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, roiBasedSensitivityModifierCount));
        }
    }

    // zoomBasedSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("zoomBasedSensitivityModifier", ParameterParserDataType::Structure, true, false, zoomBasedSensitivityModifierCount));
    }
    else if (PARAMETER_STRCMP(__name, "zoomBasedSensitivityModifier") == 0)
    {
        if (__index < zoomBasedSensitivityModifierCount)
        {
            __result = zoomBasedSensitivityModifier[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, zoomBasedSensitivityModifierCount));
        }
    }

    // gainBasedSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("gainBasedSensitivityModifier", ParameterParserDataType::Structure, true, false, gainBasedSensitivityModifierCount));
    }
    else if (PARAMETER_STRCMP(__name, "gainBasedSensitivityModifier") == 0)
    {
        if (__index < gainBasedSensitivityModifierCount)
        {
            __result = gainBasedSensitivityModifier[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, gainBasedSensitivityModifierCount));
        }
    }

    return __result;
}

bool sensitivityTrigger::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "AECTrigger") == 0)
    {
        __result = AECTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "value") == 0)
    {
        ParameterUtils::DoubleToString((double)value, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool sensitivityTrigger::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "AECTrigger") == 0)
    {
        __result = AECTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "value") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            value = (INT32)dblValue; 
        }
    }

    return __result;
}

bool sensitivityTrigger::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // AECTrigger
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("AECTrigger", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "AECTrigger") == 0)
    {
        __result = AECTrigger.GetInfo(&__path[__pos], __info);
    }

    // value
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("value", ParameterParserDataType::Int32, (double)value, 0));
    }
    else if (PARAMETER_STRCMP(__name, "value") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)value, 0));
    }

    return __result;
}

bool sensitivitySetting::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "VMType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)VMType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "value") == 0)
    {
        ParameterUtils::DoubleToString((double)value, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerSet") == 0)
    {
        if (__index < sensitivityTriggerSetCount)
        {
            __result = sensitivityTriggerSet[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "VMSensitivityModifier") == 0)
    {
        if (VMSensitivityModifierExists)
        {
            __result = VMSensitivityModifier.GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool sensitivitySetting::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "VMType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            VMType = (chromatixVMSetTypeEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "value") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            value = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerSet") == 0)
    {
        if (__index < sensitivityTriggerSetCount)
        {
            __result = sensitivityTriggerSet[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "VMSensitivityModifier") == 0)
    {
        if (VMSensitivityModifierExists)
        {
            __result = VMSensitivityModifier.SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool sensitivitySetting::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // VMType
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("VMType", ParameterParserDataType::Enum, (double)(UINT32)VMType, 0));
    }
    else if (PARAMETER_STRCMP(__name, "VMType") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)VMType, 0));
    }

    // value
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("value", ParameterParserDataType::Int32, (double)value, 0));
    }
    else if (PARAMETER_STRCMP(__name, "value") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)value, 0));
    }

    // sensitivityTriggerSet
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensitivityTriggerSet", ParameterParserDataType::Structure, true, false, sensitivityTriggerSetCount));
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerSet") == 0)
    {
        if (__index < sensitivityTriggerSetCount)
        {
            __result = sensitivityTriggerSet[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, sensitivityTriggerSetCount));
        }
    }

    // VMSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("VMSensitivityModifier", ParameterParserDataType::Structure, false, true, VMSensitivityModifierExists));
    }
    else if (PARAMETER_STRCMP(__name, "VMSensitivityModifier") == 0)
    {
        if (VMSensitivityModifierExists)
        {
            __result = VMSensitivityModifier.GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, false, true, VMSensitivityModifierExists));
        }
    }

    return __result;
}

bool chromatixTopoAlgUtilType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "touchAssist") == 0)
    {
        ParameterUtils::DoubleToString((double)touchAssist, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixTopoAlgUtilType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "touchAssist") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            touchAssist = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixTopoAlgUtilType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // touchAssist
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("touchAssist", ParameterParserDataType::Int32, (double)touchAssist, 0));
    }
    else if (PARAMETER_STRCMP(__name, "touchAssist") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)touchAssist, 0));
    }

    // sensitivityTriggerArr
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensitivityTriggerArr", ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
        }
    }

    return __result;
}

bool chromatixTopoDepthAFType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "defocusLow") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusLow, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusHigh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "sadPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)sadPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)gyroPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)motionPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "DepthAFTopoReservedSensitivity") == 0)
    {
        if (__index < DepthAFTopoReservedSensitivityCount)
        {
            ParameterUtils::DoubleToString((double)DepthAFTopoReservedSensitivity[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < DepthAFTopoReservedSensitivityCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)DepthAFTopoReservedSensitivity[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixTopoDepthAFType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "defocusLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusLow = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusHigh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sadPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sadPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gyroPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            motionPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "DepthAFTopoReservedSensitivity") == 0)
    {
        if (__index < DepthAFTopoReservedSensitivityCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                DepthAFTopoReservedSensitivity[__index] = (INT32)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < DepthAFTopoReservedSensitivityCount)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    DepthAFTopoReservedSensitivity[__index] = (INT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixTopoDepthAFType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // defocusLow
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("defocusLow", ParameterParserDataType::Int32, (double)defocusLow, 0));
    }
    else if (PARAMETER_STRCMP(__name, "defocusLow") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)defocusLow, 0));
    }

    // defocusHigh
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("defocusHigh", ParameterParserDataType::Int32, (double)defocusHigh, 0));
    }
    else if (PARAMETER_STRCMP(__name, "defocusHigh") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)defocusHigh, 0));
    }

    // defocusPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("defocusPanning", ParameterParserDataType::Int32, (double)defocusPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "defocusPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)defocusPanning, 0));
    }

    // sadPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sadPanning", ParameterParserDataType::Int32, (double)sadPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "sadPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)sadPanning, 0));
    }

    // gyroPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("gyroPanning", ParameterParserDataType::Int32, (double)gyroPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)gyroPanning, 0));
    }

    // motionPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("motionPanning", ParameterParserDataType::Int32, (double)motionPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)motionPanning, 0));
    }

    // DepthAFTopoReservedSensitivity
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("DepthAFTopoReservedSensitivity", ParameterParserDataType::Int32, true, false, DepthAFTopoReservedSensitivityCount));
    }

    // sensitivityTriggerArr
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensitivityTriggerArr", ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
        }
    }

    // topoSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoSensitivityModifier", ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
        }
    }

    return __result;
}

bool chromatixTopoDefaultMixerType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "secondarySceneChangeCntThres") == 0)
    {
        ParameterUtils::DoubleToString((double)secondarySceneChangeCntThres, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "secondaryUnstableCntThres") == 0)
    {
        ParameterUtils::DoubleToString((double)secondaryUnstableCntThres, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyroEnable") == 0)
    {
        ParameterUtils::DoubleToString((double)gyroEnable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixTopoDefaultMixerType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "secondarySceneChangeCntThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            secondarySceneChangeCntThres = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "secondaryUnstableCntThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            secondaryUnstableCntThres = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyroEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gyroEnable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixTopoDefaultMixerType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // secondarySceneChangeCntThres
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("secondarySceneChangeCntThres", ParameterParserDataType::Int32, (double)secondarySceneChangeCntThres, 0));
    }
    else if (PARAMETER_STRCMP(__name, "secondarySceneChangeCntThres") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)secondarySceneChangeCntThres, 0));
    }

    // secondaryUnstableCntThres
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("secondaryUnstableCntThres", ParameterParserDataType::Int32, (double)secondaryUnstableCntThres, 0));
    }
    else if (PARAMETER_STRCMP(__name, "secondaryUnstableCntThres") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)secondaryUnstableCntThres, 0));
    }

    // gyroEnable
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("gyroEnable", ParameterParserDataType::Int32, (double)gyroEnable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "gyroEnable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)gyroEnable, 0));
    }

    // sensitivityTriggerArr
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensitivityTriggerArr", ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
        }
    }

    // topoSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoSensitivityModifier", ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
        }
    }

    return __result;
}

bool chromatixTopoTOFType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)profileIndex, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "distance") == 0)
    {
        ParameterUtils::DoubleToString((double)distance, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TOFconfidenceHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)TOFconfidenceHigh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TOFconfidenceMedium") == 0)
    {
        ParameterUtils::DoubleToString((double)TOFconfidenceMedium, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)SADPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)gyroPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)motionPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TOFTopoReservedSensitivity") == 0)
    {
        if (__index < TOFTopoReservedSensitivityCount)
        {
            ParameterUtils::DoubleToString((double)TOFTopoReservedSensitivity[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < TOFTopoReservedSensitivityCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)TOFTopoReservedSensitivity[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixTopoTOFType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            profileIndex = (chromatixTopoTOFEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "distance") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            distance = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TOFconfidenceHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TOFconfidenceHigh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TOFconfidenceMedium") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TOFconfidenceMedium = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            SADPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gyroPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            motionPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TOFTopoReservedSensitivity") == 0)
    {
        if (__index < TOFTopoReservedSensitivityCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                TOFTopoReservedSensitivity[__index] = (INT32)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < TOFTopoReservedSensitivityCount)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    TOFTopoReservedSensitivity[__index] = (INT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixTopoTOFType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // profileIndex
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("profileIndex", ParameterParserDataType::Enum, (double)(UINT32)profileIndex, 0));
    }
    else if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)profileIndex, 0));
    }

    // distance
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("distance", ParameterParserDataType::Int32, (double)distance, 0));
    }
    else if (PARAMETER_STRCMP(__name, "distance") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)distance, 0));
    }

    // TOFconfidenceHigh
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("TOFconfidenceHigh", ParameterParserDataType::Int32, (double)TOFconfidenceHigh, 0));
    }
    else if (PARAMETER_STRCMP(__name, "TOFconfidenceHigh") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)TOFconfidenceHigh, 0));
    }

    // TOFconfidenceMedium
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("TOFconfidenceMedium", ParameterParserDataType::Int32, (double)TOFconfidenceMedium, 0));
    }
    else if (PARAMETER_STRCMP(__name, "TOFconfidenceMedium") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)TOFconfidenceMedium, 0));
    }

    // SADPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("SADPanning", ParameterParserDataType::Int32, (double)SADPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)SADPanning, 0));
    }

    // gyroPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("gyroPanning", ParameterParserDataType::Int32, (double)gyroPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)gyroPanning, 0));
    }

    // motionPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("motionPanning", ParameterParserDataType::Int32, (double)motionPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)motionPanning, 0));
    }

    // TOFTopoReservedSensitivity
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("TOFTopoReservedSensitivity", ParameterParserDataType::Int32, true, false, TOFTopoReservedSensitivityCount));
    }

    // sensitivityTriggerArr
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensitivityTriggerArr", ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
        }
    }

    // topoSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoSensitivityModifier", ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
        }
    }

    return __result;
}

bool chromatixTopoPDAFType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)profileIndex, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusLow") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusLow, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusHigh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "PDAFconfidence") == 0)
    {
        ParameterUtils::DoubleToString((double)PDAFconfidence, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)SADPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)gyroPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)motionPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "PDAFTopoReservedSensitivity") == 0)
    {
        if (__index < PDAFTopoReservedSensitivityCount)
        {
            ParameterUtils::DoubleToString((double)PDAFTopoReservedSensitivity[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < PDAFTopoReservedSensitivityCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)PDAFTopoReservedSensitivity[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixTopoPDAFType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            profileIndex = (chromatixTopoPDAFEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusLow = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusHigh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDAFconfidence") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            PDAFconfidence = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            SADPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gyroPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            motionPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDAFTopoReservedSensitivity") == 0)
    {
        if (__index < PDAFTopoReservedSensitivityCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                PDAFTopoReservedSensitivity[__index] = (INT32)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < PDAFTopoReservedSensitivityCount)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    PDAFTopoReservedSensitivity[__index] = (INT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixTopoPDAFType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // profileIndex
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("profileIndex", ParameterParserDataType::Enum, (double)(UINT32)profileIndex, 0));
    }
    else if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)profileIndex, 0));
    }

    // defocusLow
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("defocusLow", ParameterParserDataType::Int32, (double)defocusLow, 0));
    }
    else if (PARAMETER_STRCMP(__name, "defocusLow") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)defocusLow, 0));
    }

    // defocusHigh
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("defocusHigh", ParameterParserDataType::Int32, (double)defocusHigh, 0));
    }
    else if (PARAMETER_STRCMP(__name, "defocusHigh") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)defocusHigh, 0));
    }

    // PDAFconfidence
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("PDAFconfidence", ParameterParserDataType::Int32, (double)PDAFconfidence, 0));
    }
    else if (PARAMETER_STRCMP(__name, "PDAFconfidence") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)PDAFconfidence, 0));
    }

    // SADPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("SADPanning", ParameterParserDataType::Int32, (double)SADPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)SADPanning, 0));
    }

    // gyroPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("gyroPanning", ParameterParserDataType::Int32, (double)gyroPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)gyroPanning, 0));
    }

    // motionPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("motionPanning", ParameterParserDataType::Int32, (double)motionPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)motionPanning, 0));
    }

    // PDAFTopoReservedSensitivity
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("PDAFTopoReservedSensitivity", ParameterParserDataType::Int32, true, false, PDAFTopoReservedSensitivityCount));
    }

    // sensitivityTriggerArr
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensitivityTriggerArr", ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
        }
    }

    // topoSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoSensitivityModifier", ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
        }
    }

    return __result;
}

bool chromatixTopoCAFType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)profileIndex, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "SADR") == 0)
    {
        ParameterUtils::DoubleToString((double)SADR, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyro") == 0)
    {
        ParameterUtils::DoubleToString((double)gyro, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "motion") == 0)
    {
        ParameterUtils::DoubleToString((double)motion, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)gyroPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)motionPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        ParameterUtils::DoubleToString((double)SADPanning, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FV") == 0)
    {
        ParameterUtils::DoubleToString((double)FV, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "faceTriggerHold") == 0)
    {
        ParameterUtils::DoubleToString((double)faceTriggerHold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "CAFSceneChangeHold") == 0)
    {
        ParameterUtils::DoubleToString((double)CAFSceneChangeHold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "CAFTopoReservedSensitivity") == 0)
    {
        if (__index < CAFTopoReservedSensitivityCount)
        {
            ParameterUtils::DoubleToString((double)CAFTopoReservedSensitivity[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < CAFTopoReservedSensitivityCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)CAFTopoReservedSensitivity[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixTopoCAFType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            profileIndex = (chromatixTopoCAFEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "SADR") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            SADR = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyro") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gyro = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "motion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            motion = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gyroPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            motionPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            SADPanning = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FV") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FV = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "faceTriggerHold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            faceTriggerHold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "CAFSceneChangeHold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            CAFSceneChangeHold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "CAFTopoReservedSensitivity") == 0)
    {
        if (__index < CAFTopoReservedSensitivityCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                CAFTopoReservedSensitivity[__index] = (INT32)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

            __index = 0;
            while (__pos < __valueLen && __index < CAFTopoReservedSensitivityCount)
            {
                CHAR __valueStr[MAX_SIZE];

                __pos += ParameterUtils::GetSubString(&__value[__pos], ',', __valueStr, MAX_SIZE);
                __pos++;

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    CAFTopoReservedSensitivity[__index] = (INT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixTopoCAFType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // profileIndex
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("profileIndex", ParameterParserDataType::Enum, (double)(UINT32)profileIndex, 0));
    }
    else if (PARAMETER_STRCMP(__name, "profileIndex") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Enum, (double)(UINT32)profileIndex, 0));
    }

    // SADR
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("SADR", ParameterParserDataType::Int32, (double)SADR, 0));
    }
    else if (PARAMETER_STRCMP(__name, "SADR") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)SADR, 0));
    }

    // gyro
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("gyro", ParameterParserDataType::Int32, (double)gyro, 0));
    }
    else if (PARAMETER_STRCMP(__name, "gyro") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)gyro, 0));
    }

    // motion
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("motion", ParameterParserDataType::Int32, (double)motion, 0));
    }
    else if (PARAMETER_STRCMP(__name, "motion") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)motion, 0));
    }

    // gyroPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("gyroPanning", ParameterParserDataType::Int32, (double)gyroPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "gyroPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)gyroPanning, 0));
    }

    // motionPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("motionPanning", ParameterParserDataType::Int32, (double)motionPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "motionPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)motionPanning, 0));
    }

    // SADPanning
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("SADPanning", ParameterParserDataType::Int32, (double)SADPanning, 0));
    }
    else if (PARAMETER_STRCMP(__name, "SADPanning") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)SADPanning, 0));
    }

    // FV
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("FV", ParameterParserDataType::Int32, (double)FV, 0));
    }
    else if (PARAMETER_STRCMP(__name, "FV") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)FV, 0));
    }

    // faceTriggerHold
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("faceTriggerHold", ParameterParserDataType::Int32, (double)faceTriggerHold, 0));
    }
    else if (PARAMETER_STRCMP(__name, "faceTriggerHold") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)faceTriggerHold, 0));
    }

    // CAFSceneChangeHold
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("CAFSceneChangeHold", ParameterParserDataType::Int32, (double)CAFSceneChangeHold, 0));
    }
    else if (PARAMETER_STRCMP(__name, "CAFSceneChangeHold") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)CAFSceneChangeHold, 0));
    }

    // CAFTopoReservedSensitivity
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("CAFTopoReservedSensitivity", ParameterParserDataType::Int32, true, false, CAFTopoReservedSensitivityCount));
    }

    // sensitivityTriggerArr
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("sensitivityTriggerArr", ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityTriggerArr") == 0)
    {
        if (__index < sensitivityTriggerArrCount)
        {
            __result = sensitivityTriggerArr[__index].GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, true, false, sensitivityTriggerArrCount));
        }
    }

    // topoSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoSensitivityModifier", ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
    }
    else if (PARAMETER_STRCMP(__name, "topoSensitivityModifier") == 0)
    {
        if (topoSensitivityModifierExists)
        {
            __result = topoSensitivityModifier.GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, false, true, topoSensitivityModifierExists));
        }
    }

    return __result;
}

bool chromatixMonitorAlgoConfigType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "topoCAF") == 0)
    {
        __result = topoCAF.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "topoPDAF") == 0)
    {
        __result = topoPDAF.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "topoTOF") == 0)
    {
        __result = topoTOF.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "topoDefaultMixer") == 0)
    {
        __result = topoDefaultMixer.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "topoDepthAF") == 0)
    {
        __result = topoDepthAF.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "globalSensitivityModifier") == 0)
    {
        if (globalSensitivityModifierExists)
        {
            __result = globalSensitivityModifier.GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoAlgUtil") == 0)
    {
        __result = topoAlgUtil.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixMonitorAlgoConfigType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "topoCAF") == 0)
    {
        __result = topoCAF.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "topoPDAF") == 0)
    {
        __result = topoPDAF.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "topoTOF") == 0)
    {
        __result = topoTOF.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "topoDefaultMixer") == 0)
    {
        __result = topoDefaultMixer.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "topoDepthAF") == 0)
    {
        __result = topoDepthAF.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "globalSensitivityModifier") == 0)
    {
        if (globalSensitivityModifierExists)
        {
            __result = globalSensitivityModifier.SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "topoAlgUtil") == 0)
    {
        __result = topoAlgUtil.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixMonitorAlgoConfigType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // topoCAF
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoCAF", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "topoCAF") == 0)
    {
        __result = topoCAF.GetInfo(&__path[__pos], __info);
    }

    // topoPDAF
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoPDAF", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "topoPDAF") == 0)
    {
        __result = topoPDAF.GetInfo(&__path[__pos], __info);
    }

    // topoTOF
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoTOF", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "topoTOF") == 0)
    {
        __result = topoTOF.GetInfo(&__path[__pos], __info);
    }

    // topoDefaultMixer
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoDefaultMixer", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "topoDefaultMixer") == 0)
    {
        __result = topoDefaultMixer.GetInfo(&__path[__pos], __info);
    }

    // topoDepthAF
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoDepthAF", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "topoDepthAF") == 0)
    {
        __result = topoDepthAF.GetInfo(&__path[__pos], __info);
    }

    // globalSensitivityModifier
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("globalSensitivityModifier", ParameterParserDataType::Structure, false, true, globalSensitivityModifierExists));
    }
    else if (PARAMETER_STRCMP(__name, "globalSensitivityModifier") == 0)
    {
        if (globalSensitivityModifierExists)
        {
            __result = globalSensitivityModifier.GetInfo(&__path[__pos], __info);
        }
        else
        {
            __result = true;
            __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Structure, false, true, globalSensitivityModifierExists));
        }
    }

    // topoAlgUtil
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("topoAlgUtil", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "topoAlgUtil") == 0)
    {
        __result = topoAlgUtil.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool chromatixAFMONITORType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "monitorAlgoConfig") == 0)
    {
        __result = monitorAlgoConfig.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "valueMonitorBank") == 0)
    {
        __result = valueMonitorBank.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixAFMONITORType::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "monitorAlgoConfig") == 0)
    {
        __result = monitorAlgoConfig.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "valueMonitorBank") == 0)
    {
        __result = valueMonitorBank.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixAFMONITORType::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    const UINT32 __pos = ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // module_version
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("module_version", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.GetInfo(&__path[__pos], __info);
    }

    // parameter_version
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("parameter_version", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.GetInfo(&__path[__pos], __info);
    }

    // monitorAlgoConfig
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("monitorAlgoConfig", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "monitorAlgoConfig") == 0)
    {
        __result = monitorAlgoConfig.GetInfo(&__path[__pos], __info);
    }

    // valueMonitorBank
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("valueMonitorBank", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "valueMonitorBank") == 0)
    {
        __result = valueMonitorBank.GetInfo(&__path[__pos], __info);
    }

    return __result;
}

bool chromatixAFMONITORType::module_versionStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "major_revision") == 0)
    {
        ParameterUtils::DoubleToString((double)major_revision, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minor_revision") == 0)
    {
        ParameterUtils::DoubleToString((double)minor_revision, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "incr_revision") == 0)
    {
        ParameterUtils::DoubleToString((double)incr_revision, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixAFMONITORType::module_versionStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const __value)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "major_revision") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            major_revision = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minor_revision") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minor_revision = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "incr_revision") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            incr_revision = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixAFMONITORType::module_versionStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // major_revision
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("major_revision", ParameterParserDataType::Int32, (double)major_revision, 0));
    }
    else if (PARAMETER_STRCMP(__name, "major_revision") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)major_revision, 0));
    }

    // minor_revision
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("minor_revision", ParameterParserDataType::Int32, (double)minor_revision, 0));
    }
    else if (PARAMETER_STRCMP(__name, "minor_revision") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)minor_revision, 0));
    }

    // incr_revision
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("incr_revision", ParameterParserDataType::Int32, (double)incr_revision, 0));
    }
    else if (PARAMETER_STRCMP(__name, "incr_revision") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Int32, (double)incr_revision, 0));
    }

    return __result;
}

bool chromatixAFMONITORType::parameter_versionStruct::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "revision") == 0)
    {
        PARAMETER_STRCPY(__value, __size, revision);
        __result = true;
    }

    return __result;
}

bool chromatixAFMONITORType::parameter_versionStruct::SetValue(
    const CHAR* const __path,
    const CHAR* const /*__value*/)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    if (PARAMETER_STRCMP(__name, "revision") == 0)
    {
        // Cannot modify strings, risk of memory leaks or corruption
    }

    return __result;
}

bool chromatixAFMONITORType::parameter_versionStruct::GetInfo(
    const CHAR* const           __path,
    PList<ParameterParserInfo>& __info)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

    ParameterUtils::GetVariable(__path, __name, __index, MAX_SIZE);

    // revision
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("revision", ParameterParserDataType::String, revision));
    }
    else if (PARAMETER_STRCMP(__name, "revision") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::String, revision));
    }

    return __result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_chromatixVMStateEnum(
    ParameterFileSymbolTableEntry* const entry,
    chromatixVMStateEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

    UINT32 uintValue {entry->ReadEnum(&result, alignment)};

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixVMStateEnum::VMSTATEINVALID):
            enumValue = chromatixVMStateEnum::VMSTATEINVALID;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMStateEnum::VMSTATELOW):
            enumValue = chromatixVMStateEnum::VMSTATELOW;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMStateEnum::VMSTATEHIGH):
            enumValue = chromatixVMStateEnum::VMSTATEHIGH;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixVMStateEnum", uintValue);
            break;
        }
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_chromatixDetectorTypeEnum(
    ParameterFileSymbolTableEntry* const entry,
    chromatixDetectorTypeEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

    UINT32 uintValue {entry->ReadEnum(&result, alignment)};

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixDetectorTypeEnum::VMDetectorInvalid):
            enumValue = chromatixDetectorTypeEnum::VMDetectorInvalid;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixDetectorTypeEnum::VMDetectorStable):
            enumValue = chromatixDetectorTypeEnum::VMDetectorStable;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixDetectorTypeEnum::VMDetectorUnstable):
            enumValue = chromatixDetectorTypeEnum::VMDetectorUnstable;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixDetectorTypeEnum", uintValue);
            break;
        }
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_chromatixVMSetTypeEnum(
    ParameterFileSymbolTableEntry* const entry,
    chromatixVMSetTypeEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

    UINT32 uintValue {entry->ReadEnum(&result, alignment)};

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeSADR):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeSADR;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeSADPanning):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeSADPanning;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeGyro):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeGyro;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeGyroPanning):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeGyroPanning;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeDefocusLow):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeDefocusLow;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeDefocusHigh):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeDefocusHigh;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeTOFConfidenceHigh):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeTOFConfidenceHigh;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypePDAFConfidence):
            enumValue = chromatixVMSetTypeEnum::VmSetTypePDAFConfidence;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeDistance):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeDistance;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeFV):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeFV;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeTOFConfidenceMedium):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeTOFConfidenceMedium;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeFaceTriggerHold):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeFaceTriggerHold;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCAFSceneChangeHold):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCAFSceneChangeHold;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeDistancePanning):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeDistancePanning;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeDepthAFDefocusPanning):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeDepthAFDefocusPanning;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeMotion):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeMotion;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeMotionPanning):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeMotionPanning;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeTouchAssist):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeTouchAssist;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom1):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom1;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom2):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom2;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom3):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom3;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom4):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom4;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom5):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom5;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom6):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom6;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom7):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom7;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom8):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom8;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom9):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom9;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeCustom10):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeCustom10;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixVMSetTypeEnum::VmSetTypeMax):
            enumValue = chromatixVMSetTypeEnum::VmSetTypeMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixVMSetTypeEnum", uintValue);
            break;
        }
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_chromatixTopoTOFEnum(
    ParameterFileSymbolTableEntry* const entry,
    chromatixTopoTOFEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

    UINT32 uintValue {entry->ReadEnum(&result, alignment)};

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixTopoTOFEnum::TOFTopoProfileSimple):
            enumValue = chromatixTopoTOFEnum::TOFTopoProfileSimple;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoTOFEnum::TOFTopoProfileAdvanced):
            enumValue = chromatixTopoTOFEnum::TOFTopoProfileAdvanced;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoTOFEnum::TOFTopoProfileMax):
            enumValue = chromatixTopoTOFEnum::TOFTopoProfileMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixTopoTOFEnum", uintValue);
            break;
        }
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_chromatixTopoPDAFEnum(
    ParameterFileSymbolTableEntry* const entry,
    chromatixTopoPDAFEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

    UINT32 uintValue {entry->ReadEnum(&result, alignment)};

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixTopoPDAFEnum::PDAFTopoProfileSparse):
            enumValue = chromatixTopoPDAFEnum::PDAFTopoProfileSparse;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoPDAFEnum::PDAFTopoProfile2PD):
            enumValue = chromatixTopoPDAFEnum::PDAFTopoProfile2PD;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoPDAFEnum::PDAFTopoProfileSparseAdvanced):
            enumValue = chromatixTopoPDAFEnum::PDAFTopoProfileSparseAdvanced;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoPDAFEnum::PDAFTopoProfile2PDAdvanced):
            enumValue = chromatixTopoPDAFEnum::PDAFTopoProfile2PDAdvanced;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoPDAFEnum::PDAFTopoProfileAdvanced):
            enumValue = chromatixTopoPDAFEnum::PDAFTopoProfileAdvanced;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoPDAFEnum::PDAFTOPOProfileMAX):
            enumValue = chromatixTopoPDAFEnum::PDAFTOPOProfileMAX;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixTopoPDAFEnum", uintValue);
            break;
        }
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_chromatixTopoCAFEnum(
    ParameterFileSymbolTableEntry* const entry,
    chromatixTopoCAFEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

    UINT32 uintValue {entry->ReadEnum(&result, alignment)};

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixTopoCAFEnum::CAFTopoProfileSimple):
            enumValue = chromatixTopoCAFEnum::CAFTopoProfileSimple;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoCAFEnum::CAFTopoProfileAdvanced):
            enumValue = chromatixTopoCAFEnum::CAFTopoProfileAdvanced;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoCAFEnum::CAFTopoProfileMax):
            enumValue = chromatixTopoCAFEnum::CAFTopoProfileMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixTopoCAFEnum", uintValue);
            break;
        }
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Read enum value
/// @param entry [in] Symbol table entry
/// @param enumValue [out] Enum value to read
/// @param alignment [in] Symbol table byte alignment
/// @return true if successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ReadEnum_chromatixTopoDCIAFEnum(
    ParameterFileSymbolTableEntry* const entry,
    chromatixTopoDCIAFEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

    UINT32 uintValue {entry->ReadEnum(&result, alignment)};

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixTopoDCIAFEnum::DCIAFTopoProfileSimple):
            enumValue = chromatixTopoDCIAFEnum::DCIAFTopoProfileSimple;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoDCIAFEnum::DCIAFTopoProfileAdvanced):
            enumValue = chromatixTopoDCIAFEnum::DCIAFTopoProfileAdvanced;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixTopoDCIAFEnum::DCIAFTopoProfileMax):
            enumValue = chromatixTopoDCIAFEnum::DCIAFTopoProfileMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixTopoDCIAFEnum", uintValue);
            break;
        }
    }
    return result;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixAFMONITORTypeClass::chromatixAFMONITORTypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(monitorAlgoConfig);
    PARAMETER_INITIALIZE(valueMonitorBank);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixAFMONITORTypeClass::chromatixAFMONITORTypeClass(
    const CHAR* const name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(monitorAlgoConfig);
    PARAMETER_INITIALIZE(valueMonitorBank);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Destructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixAFMONITORTypeClass::~chromatixAFMONITORTypeClass()
{
    if (Loaded)
    {
        UnloadModule();
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GetName
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CHAR* chromatixAFMONITORTypeClass::GetName(
    const CHAR* const type)
{
    const CHAR* name = type;
    CHAR temp[ParameterFileSymbolTableEntry::TYPE_LEN + 1];
    if (PARAMETER_STRCMP(type, ModuleData::GetType(temp, "chromatixAFMONITOR")) == 0)
    {
        name = "chromatixAFMONITOR";
    }
    return name;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixIirFltrCfgType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixIirFltrCfgType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(numOfSamples);
    PARAMETER_INITIALIZE(coeffNumerator);
    PARAMETER_INITIALIZE(coeffDenominator);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numOfSamples, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, coeffNumerator, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, coeffDenominator, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixMvavgFltrCfgType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixMvavgFltrCfgType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(numOfSamples);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numOfSamples, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixMedianFltrCfgType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixMedianFltrCfgType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(numOfSamples);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numOfSamples, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixSensProfileType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixSensProfileType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(triggerThreshold);
    PARAMETER_INITIALIZE(consecutiveCountThreshold);
    PARAMETER_INITIALIZE(frameToArmed);
    PARAMETER_INITIALIZE(highCountThreshold);
    PARAMETER_INITIALIZE(lowCountThreshold);
    PARAMETER_INITIALIZE(medianFltrCfg);
    PARAMETER_INITIALIZE(mvavgFltrCfg);
    PARAMETER_INITIALIZE(IIRFltrCfg);

    SYMBOL_TABLE_ENTRY_READ(entry, result, triggerThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, consecutiveCountThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frameToArmed, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, highCountThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, lowCountThreshold, alignment)
    if (result)
    {
        result = medianFltrCfg.Load(entry, alignment);
    }
    if (result)
    {
        result = mvavgFltrCfg.Load(entry, alignment);
    }
    if (result)
    {
        result = IIRFltrCfg.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixAbsoluteModeCfgType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixAbsoluteModeCfgType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(baseline);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, baseline, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixValueMonitorType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixValueMonitorType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(VMSetType);
    PARAMETER_INITIALIZE(detectionType);
    PARAMETER_INITIALIZE(VMInitState);
    PARAMETER_INITIALIZE(absoluteModeCfg);
    PARAMETER_INITIALIZE(sensProfileLow);
    PARAMETER_INITIALIZE(sensProfileMed);
    PARAMETER_INITIALIZE(sensProfileHigh);

    result = afmonitorelements::ReadEnum_chromatixVMSetTypeEnum(entry, VMSetType, alignment);
    if (result)
    {
        result = afmonitorelements::ReadEnum_chromatixDetectorTypeEnum(entry, detectionType, alignment);
    }
    if (result)
    {
        result = afmonitorelements::ReadEnum_chromatixVMStateEnum(entry, VMInitState, alignment);
    }
    if (result)
    {
        result = absoluteModeCfg.Load(entry, alignment);
    }
    if (result)
    {
        result = sensProfileLow.Load(entry, alignment);
    }
    if (result)
    {
        result = sensProfileMed.Load(entry, alignment);
    }
    if (result)
    {
        result = sensProfileHigh.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixValueMonitorBankType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixValueMonitorBankType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(valueMonitor);


    // Reading Array valueMonitor from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        valueMonitorCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, valueMonitorCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            valueMonitorID = pointerEntry->ID;
            DupObjInfo* valueMonitorDupInfo = pointerEntry->GetDupObject(valueMonitorCount, file, line);
            if (valueMonitorDupInfo != nullptr && valueMonitorDupInfo->Object != nullptr)
            {
                valueMonitor = (chromatixValueMonitorType*)valueMonitorDupInfo->Object;
                if (valueMonitor == nullptr)
                {
                    if (valueMonitorDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "valueMonitor duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            valueMonitorDupInfo->File, valueMonitorDupInfo->Line, valueMonitorDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "valueMonitor duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            valueMonitorDupInfo->Line, valueMonitorDupInfo->RefCount);
                    }
                }
            }

            if (valueMonitor == nullptr)
            {
                if (result && valueMonitorCount > 0)
                {
                    valueMonitor = PARAMETER_NEW chromatixValueMonitorType[valueMonitorCount];
                    (void)pointerEntry->SetDupObject(valueMonitor, valueMonitorCount, file, line);
                }
                if (!result || valueMonitor == nullptr)
                {
                    if (valueMonitorCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate valueMonitor\n");
                    }
                    valueMonitorCount = 0;
                }
                for (UINT32 i = 0; result && i < valueMonitorCount; i++)
                {
                    result = valueMonitor[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (valueMonitor == nullptr)
        {
            valueMonitorCount = 0;
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load sensitivityModifierArr
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool sensitivityModifierArr::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(roiBasedSensitivityModifier);
    PARAMETER_INITIALIZE(zoomBasedSensitivityModifier);
    PARAMETER_INITIALIZE(gainBasedSensitivityModifier);


    // Reading Array roiBasedSensitivityModifier from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        roiBasedSensitivityModifierCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, roiBasedSensitivityModifierCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            roiBasedSensitivityModifierID = pointerEntry->ID;
            DupObjInfo* roiBasedSensitivityModifierDupInfo = pointerEntry->GetDupObject(roiBasedSensitivityModifierCount, file, line);
            if (roiBasedSensitivityModifierDupInfo != nullptr && roiBasedSensitivityModifierDupInfo->Object != nullptr)
            {
                roiBasedSensitivityModifier = (afglobalelements::ROITypeSensitivityModifier*)roiBasedSensitivityModifierDupInfo->Object;
                if (roiBasedSensitivityModifier == nullptr)
                {
                    if (roiBasedSensitivityModifierDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "roiBasedSensitivityModifier duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            roiBasedSensitivityModifierDupInfo->File, roiBasedSensitivityModifierDupInfo->Line, roiBasedSensitivityModifierDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "roiBasedSensitivityModifier duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            roiBasedSensitivityModifierDupInfo->Line, roiBasedSensitivityModifierDupInfo->RefCount);
                    }
                }
            }

            if (roiBasedSensitivityModifier == nullptr)
            {
                if (result && roiBasedSensitivityModifierCount > 0)
                {
                    roiBasedSensitivityModifier = PARAMETER_NEW afglobalelements::ROITypeSensitivityModifier[roiBasedSensitivityModifierCount];
                    (void)pointerEntry->SetDupObject(roiBasedSensitivityModifier, roiBasedSensitivityModifierCount, file, line);
                }
                if (!result || roiBasedSensitivityModifier == nullptr)
                {
                    if (roiBasedSensitivityModifierCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate roiBasedSensitivityModifier\n");
                    }
                    roiBasedSensitivityModifierCount = 0;
                }
                for (UINT32 i = 0; result && i < roiBasedSensitivityModifierCount; i++)
                {
                    result = roiBasedSensitivityModifier[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (roiBasedSensitivityModifier == nullptr)
        {
            roiBasedSensitivityModifierCount = 0;
        }
    }

    // Reading Array zoomBasedSensitivityModifier from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        zoomBasedSensitivityModifierCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, zoomBasedSensitivityModifierCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            zoomBasedSensitivityModifierID = pointerEntry->ID;
            DupObjInfo* zoomBasedSensitivityModifierDupInfo = pointerEntry->GetDupObject(zoomBasedSensitivityModifierCount, file, line);
            if (zoomBasedSensitivityModifierDupInfo != nullptr && zoomBasedSensitivityModifierDupInfo->Object != nullptr)
            {
                zoomBasedSensitivityModifier = (afglobalelements::ZoomTypeSensitivityModifier*)zoomBasedSensitivityModifierDupInfo->Object;
                if (zoomBasedSensitivityModifier == nullptr)
                {
                    if (zoomBasedSensitivityModifierDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "zoomBasedSensitivityModifier duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            zoomBasedSensitivityModifierDupInfo->File, zoomBasedSensitivityModifierDupInfo->Line, zoomBasedSensitivityModifierDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "zoomBasedSensitivityModifier duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            zoomBasedSensitivityModifierDupInfo->Line, zoomBasedSensitivityModifierDupInfo->RefCount);
                    }
                }
            }

            if (zoomBasedSensitivityModifier == nullptr)
            {
                if (result && zoomBasedSensitivityModifierCount > 0)
                {
                    zoomBasedSensitivityModifier = PARAMETER_NEW afglobalelements::ZoomTypeSensitivityModifier[zoomBasedSensitivityModifierCount];
                    (void)pointerEntry->SetDupObject(zoomBasedSensitivityModifier, zoomBasedSensitivityModifierCount, file, line);
                }
                if (!result || zoomBasedSensitivityModifier == nullptr)
                {
                    if (zoomBasedSensitivityModifierCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate zoomBasedSensitivityModifier\n");
                    }
                    zoomBasedSensitivityModifierCount = 0;
                }
                for (UINT32 i = 0; result && i < zoomBasedSensitivityModifierCount; i++)
                {
                    result = zoomBasedSensitivityModifier[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (zoomBasedSensitivityModifier == nullptr)
        {
            zoomBasedSensitivityModifierCount = 0;
        }
    }

    // Reading Array gainBasedSensitivityModifier from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        gainBasedSensitivityModifierCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, gainBasedSensitivityModifierCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            gainBasedSensitivityModifierID = pointerEntry->ID;
            DupObjInfo* gainBasedSensitivityModifierDupInfo = pointerEntry->GetDupObject(gainBasedSensitivityModifierCount, file, line);
            if (gainBasedSensitivityModifierDupInfo != nullptr && gainBasedSensitivityModifierDupInfo->Object != nullptr)
            {
                gainBasedSensitivityModifier = (afglobalelements::sensorGainTypeSensitivityModifier*)gainBasedSensitivityModifierDupInfo->Object;
                if (gainBasedSensitivityModifier == nullptr)
                {
                    if (gainBasedSensitivityModifierDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "gainBasedSensitivityModifier duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            gainBasedSensitivityModifierDupInfo->File, gainBasedSensitivityModifierDupInfo->Line, gainBasedSensitivityModifierDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "gainBasedSensitivityModifier duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            gainBasedSensitivityModifierDupInfo->Line, gainBasedSensitivityModifierDupInfo->RefCount);
                    }
                }
            }

            if (gainBasedSensitivityModifier == nullptr)
            {
                if (result && gainBasedSensitivityModifierCount > 0)
                {
                    gainBasedSensitivityModifier = PARAMETER_NEW afglobalelements::sensorGainTypeSensitivityModifier[gainBasedSensitivityModifierCount];
                    (void)pointerEntry->SetDupObject(gainBasedSensitivityModifier, gainBasedSensitivityModifierCount, file, line);
                }
                if (!result || gainBasedSensitivityModifier == nullptr)
                {
                    if (gainBasedSensitivityModifierCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate gainBasedSensitivityModifier\n");
                    }
                    gainBasedSensitivityModifierCount = 0;
                }
                for (UINT32 i = 0; result && i < gainBasedSensitivityModifierCount; i++)
                {
                    result = gainBasedSensitivityModifier[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (gainBasedSensitivityModifier == nullptr)
        {
            gainBasedSensitivityModifierCount = 0;
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load sensitivityTrigger
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool sensitivityTrigger::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(AECTrigger);
    PARAMETER_INITIALIZE(value);

    result = AECTrigger.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load sensitivitySetting
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool sensitivitySetting::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(VMType);
    PARAMETER_INITIALIZE(value);
    PARAMETER_INITIALIZE(sensitivityTriggerSet);
    PARAMETER_INITIALIZE(VMSensitivityModifierExists);
    PARAMETER_INITIALIZE(VMSensitivityModifier);

    result = afmonitorelements::ReadEnum_chromatixVMSetTypeEnum(entry, VMType, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    // Reading Array sensitivityTriggerSet from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        sensitivityTriggerSetCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, sensitivityTriggerSetCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            sensitivityTriggerSetID = pointerEntry->ID;
            DupObjInfo* sensitivityTriggerSetDupInfo = pointerEntry->GetDupObject(sensitivityTriggerSetCount, file, line);
            if (sensitivityTriggerSetDupInfo != nullptr && sensitivityTriggerSetDupInfo->Object != nullptr)
            {
                sensitivityTriggerSet = (sensitivityTrigger*)sensitivityTriggerSetDupInfo->Object;
                if (sensitivityTriggerSet == nullptr)
                {
                    if (sensitivityTriggerSetDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerSet duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            sensitivityTriggerSetDupInfo->File, sensitivityTriggerSetDupInfo->Line, sensitivityTriggerSetDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerSet duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            sensitivityTriggerSetDupInfo->Line, sensitivityTriggerSetDupInfo->RefCount);
                    }
                }
            }

            if (sensitivityTriggerSet == nullptr)
            {
                if (result && sensitivityTriggerSetCount > 0)
                {
                    sensitivityTriggerSet = PARAMETER_NEW sensitivityTrigger[sensitivityTriggerSetCount];
                    (void)pointerEntry->SetDupObject(sensitivityTriggerSet, sensitivityTriggerSetCount, file, line);
                }
                if (!result || sensitivityTriggerSet == nullptr)
                {
                    if (sensitivityTriggerSetCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate sensitivityTriggerSet\n");
                    }
                    sensitivityTriggerSetCount = 0;
                }
                for (UINT32 i = 0; result && i < sensitivityTriggerSetCount; i++)
                {
                    result = sensitivityTriggerSet[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (sensitivityTriggerSet == nullptr)
        {
            sensitivityTriggerSetCount = 0;
        }
    }

    // Reading Optional parameter VMSensitivityModifier from symbol table
    {
        SYMBOL_TABLE_ENTRY_READ(entry, result, VMSensitivityModifierExists, alignment)
        VMSensitivityModifierID = entry->ID;
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }
        if (result && VMSensitivityModifierExists)
        {
            if (result)
            {
                result = VMSensitivityModifier.Load(pointerEntry, alignment);
            }
        }
        else
        {
            PARAMETER_INITIALIZE(VMSensitivityModifier);
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixTopoAlgUtilType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixTopoAlgUtilType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(touchAssist);
    PARAMETER_INITIALIZE(sensitivityTriggerArr);

    SYMBOL_TABLE_ENTRY_READ(entry, result, touchAssist, alignment)

    // Reading Array sensitivityTriggerArr from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        sensitivityTriggerArrCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, sensitivityTriggerArrCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            sensitivityTriggerArrID = pointerEntry->ID;
            DupObjInfo* sensitivityTriggerArrDupInfo = pointerEntry->GetDupObject(sensitivityTriggerArrCount, file, line);
            if (sensitivityTriggerArrDupInfo != nullptr && sensitivityTriggerArrDupInfo->Object != nullptr)
            {
                sensitivityTriggerArr = (sensitivitySetting*)sensitivityTriggerArrDupInfo->Object;
                if (sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->File, sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                }
            }

            if (sensitivityTriggerArr == nullptr)
            {
                if (result && sensitivityTriggerArrCount > 0)
                {
                    sensitivityTriggerArr = PARAMETER_NEW sensitivitySetting[sensitivityTriggerArrCount];
                    (void)pointerEntry->SetDupObject(sensitivityTriggerArr, sensitivityTriggerArrCount, file, line);
                }
                if (!result || sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate sensitivityTriggerArr\n");
                    }
                    sensitivityTriggerArrCount = 0;
                }
                for (UINT32 i = 0; result && i < sensitivityTriggerArrCount; i++)
                {
                    result = sensitivityTriggerArr[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (sensitivityTriggerArr == nullptr)
        {
            sensitivityTriggerArrCount = 0;
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixTopoDepthAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixTopoDepthAFType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(defocusLow);
    PARAMETER_INITIALIZE(defocusHigh);
    PARAMETER_INITIALIZE(defocusPanning);
    PARAMETER_INITIALIZE(sadPanning);
    PARAMETER_INITIALIZE(gyroPanning);
    PARAMETER_INITIALIZE(motionPanning);
    PARAMETER_INITIALIZE(DepthAFTopoReservedSensitivity);
    PARAMETER_INITIALIZE(sensitivityTriggerArr);
    PARAMETER_INITIALIZE(topoSensitivityModifierExists);
    PARAMETER_INITIALIZE(topoSensitivityModifier);

    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusHigh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, sadPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyroPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, motionPanning, alignment)

    // Reading Array DepthAFTopoReservedSensitivity from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        DepthAFTopoReservedSensitivityCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, DepthAFTopoReservedSensitivityCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            DepthAFTopoReservedSensitivityID = pointerEntry->ID;
            DupObjInfo* DepthAFTopoReservedSensitivityDupInfo = pointerEntry->GetDupObject(DepthAFTopoReservedSensitivityCount, file, line);
            if (DepthAFTopoReservedSensitivityDupInfo != nullptr && DepthAFTopoReservedSensitivityDupInfo->Object != nullptr)
            {
                DepthAFTopoReservedSensitivity = (INT32*)DepthAFTopoReservedSensitivityDupInfo->Object;
                if (DepthAFTopoReservedSensitivity == nullptr)
                {
                    if (DepthAFTopoReservedSensitivityDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "DepthAFTopoReservedSensitivity duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            DepthAFTopoReservedSensitivityDupInfo->File, DepthAFTopoReservedSensitivityDupInfo->Line, DepthAFTopoReservedSensitivityDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "DepthAFTopoReservedSensitivity duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            DepthAFTopoReservedSensitivityDupInfo->Line, DepthAFTopoReservedSensitivityDupInfo->RefCount);
                    }
                }
            }

            if (DepthAFTopoReservedSensitivity == nullptr)
            {
                if (result && DepthAFTopoReservedSensitivityCount > 0)
                {
                    DepthAFTopoReservedSensitivity = pointerEntry->ReadArray<INT32>(DepthAFTopoReservedSensitivityCount, alignment);
                    result = DepthAFTopoReservedSensitivity != nullptr;
                }
                if (!result || DepthAFTopoReservedSensitivity == nullptr)
                {
                    if (DepthAFTopoReservedSensitivityCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate DepthAFTopoReservedSensitivity\n");
                    }
                    DepthAFTopoReservedSensitivityCount = 0;
                }
            }
        }
        if (DepthAFTopoReservedSensitivity == nullptr)
        {
            DepthAFTopoReservedSensitivityCount = 0;
        }
    }

    // Reading Array sensitivityTriggerArr from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        sensitivityTriggerArrCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, sensitivityTriggerArrCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            sensitivityTriggerArrID = pointerEntry->ID;
            DupObjInfo* sensitivityTriggerArrDupInfo = pointerEntry->GetDupObject(sensitivityTriggerArrCount, file, line);
            if (sensitivityTriggerArrDupInfo != nullptr && sensitivityTriggerArrDupInfo->Object != nullptr)
            {
                sensitivityTriggerArr = (sensitivitySetting*)sensitivityTriggerArrDupInfo->Object;
                if (sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->File, sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                }
            }

            if (sensitivityTriggerArr == nullptr)
            {
                if (result && sensitivityTriggerArrCount > 0)
                {
                    sensitivityTriggerArr = PARAMETER_NEW sensitivitySetting[sensitivityTriggerArrCount];
                    (void)pointerEntry->SetDupObject(sensitivityTriggerArr, sensitivityTriggerArrCount, file, line);
                }
                if (!result || sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate sensitivityTriggerArr\n");
                    }
                    sensitivityTriggerArrCount = 0;
                }
                for (UINT32 i = 0; result && i < sensitivityTriggerArrCount; i++)
                {
                    result = sensitivityTriggerArr[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (sensitivityTriggerArr == nullptr)
        {
            sensitivityTriggerArrCount = 0;
        }
    }

    // Reading Optional parameter topoSensitivityModifier from symbol table
    {
        SYMBOL_TABLE_ENTRY_READ(entry, result, topoSensitivityModifierExists, alignment)
        topoSensitivityModifierID = entry->ID;
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }
        if (result && topoSensitivityModifierExists)
        {
            if (result)
            {
                result = topoSensitivityModifier.Load(pointerEntry, alignment);
            }
        }
        else
        {
            PARAMETER_INITIALIZE(topoSensitivityModifier);
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixTopoDefaultMixerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixTopoDefaultMixerType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(secondarySceneChangeCntThres);
    PARAMETER_INITIALIZE(secondaryUnstableCntThres);
    PARAMETER_INITIALIZE(gyroEnable);
    PARAMETER_INITIALIZE(sensitivityTriggerArr);
    PARAMETER_INITIALIZE(topoSensitivityModifierExists);
    PARAMETER_INITIALIZE(topoSensitivityModifier);

    SYMBOL_TABLE_ENTRY_READ(entry, result, secondarySceneChangeCntThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, secondaryUnstableCntThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyroEnable, alignment)

    // Reading Array sensitivityTriggerArr from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        sensitivityTriggerArrCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, sensitivityTriggerArrCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            sensitivityTriggerArrID = pointerEntry->ID;
            DupObjInfo* sensitivityTriggerArrDupInfo = pointerEntry->GetDupObject(sensitivityTriggerArrCount, file, line);
            if (sensitivityTriggerArrDupInfo != nullptr && sensitivityTriggerArrDupInfo->Object != nullptr)
            {
                sensitivityTriggerArr = (sensitivitySetting*)sensitivityTriggerArrDupInfo->Object;
                if (sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->File, sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                }
            }

            if (sensitivityTriggerArr == nullptr)
            {
                if (result && sensitivityTriggerArrCount > 0)
                {
                    sensitivityTriggerArr = PARAMETER_NEW sensitivitySetting[sensitivityTriggerArrCount];
                    (void)pointerEntry->SetDupObject(sensitivityTriggerArr, sensitivityTriggerArrCount, file, line);
                }
                if (!result || sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate sensitivityTriggerArr\n");
                    }
                    sensitivityTriggerArrCount = 0;
                }
                for (UINT32 i = 0; result && i < sensitivityTriggerArrCount; i++)
                {
                    result = sensitivityTriggerArr[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (sensitivityTriggerArr == nullptr)
        {
            sensitivityTriggerArrCount = 0;
        }
    }

    // Reading Optional parameter topoSensitivityModifier from symbol table
    {
        SYMBOL_TABLE_ENTRY_READ(entry, result, topoSensitivityModifierExists, alignment)
        topoSensitivityModifierID = entry->ID;
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }
        if (result && topoSensitivityModifierExists)
        {
            if (result)
            {
                result = topoSensitivityModifier.Load(pointerEntry, alignment);
            }
        }
        else
        {
            PARAMETER_INITIALIZE(topoSensitivityModifier);
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixTopoTOFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixTopoTOFType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(profileIndex);
    PARAMETER_INITIALIZE(distance);
    PARAMETER_INITIALIZE(TOFconfidenceHigh);
    PARAMETER_INITIALIZE(TOFconfidenceMedium);
    PARAMETER_INITIALIZE(SADPanning);
    PARAMETER_INITIALIZE(gyroPanning);
    PARAMETER_INITIALIZE(motionPanning);
    PARAMETER_INITIALIZE(TOFTopoReservedSensitivity);
    PARAMETER_INITIALIZE(sensitivityTriggerArr);
    PARAMETER_INITIALIZE(topoSensitivityModifierExists);
    PARAMETER_INITIALIZE(topoSensitivityModifier);

    result = afmonitorelements::ReadEnum_chromatixTopoTOFEnum(entry, profileIndex, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, distance, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TOFconfidenceHigh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TOFconfidenceMedium, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, SADPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyroPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, motionPanning, alignment)

    // Reading Array TOFTopoReservedSensitivity from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        TOFTopoReservedSensitivityCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, TOFTopoReservedSensitivityCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            TOFTopoReservedSensitivityID = pointerEntry->ID;
            DupObjInfo* TOFTopoReservedSensitivityDupInfo = pointerEntry->GetDupObject(TOFTopoReservedSensitivityCount, file, line);
            if (TOFTopoReservedSensitivityDupInfo != nullptr && TOFTopoReservedSensitivityDupInfo->Object != nullptr)
            {
                TOFTopoReservedSensitivity = (INT32*)TOFTopoReservedSensitivityDupInfo->Object;
                if (TOFTopoReservedSensitivity == nullptr)
                {
                    if (TOFTopoReservedSensitivityDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "TOFTopoReservedSensitivity duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            TOFTopoReservedSensitivityDupInfo->File, TOFTopoReservedSensitivityDupInfo->Line, TOFTopoReservedSensitivityDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "TOFTopoReservedSensitivity duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            TOFTopoReservedSensitivityDupInfo->Line, TOFTopoReservedSensitivityDupInfo->RefCount);
                    }
                }
            }

            if (TOFTopoReservedSensitivity == nullptr)
            {
                if (result && TOFTopoReservedSensitivityCount > 0)
                {
                    TOFTopoReservedSensitivity = pointerEntry->ReadArray<INT32>(TOFTopoReservedSensitivityCount, alignment);
                    result = TOFTopoReservedSensitivity != nullptr;
                }
                if (!result || TOFTopoReservedSensitivity == nullptr)
                {
                    if (TOFTopoReservedSensitivityCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate TOFTopoReservedSensitivity\n");
                    }
                    TOFTopoReservedSensitivityCount = 0;
                }
            }
        }
        if (TOFTopoReservedSensitivity == nullptr)
        {
            TOFTopoReservedSensitivityCount = 0;
        }
    }

    // Reading Array sensitivityTriggerArr from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        sensitivityTriggerArrCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, sensitivityTriggerArrCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            sensitivityTriggerArrID = pointerEntry->ID;
            DupObjInfo* sensitivityTriggerArrDupInfo = pointerEntry->GetDupObject(sensitivityTriggerArrCount, file, line);
            if (sensitivityTriggerArrDupInfo != nullptr && sensitivityTriggerArrDupInfo->Object != nullptr)
            {
                sensitivityTriggerArr = (sensitivitySetting*)sensitivityTriggerArrDupInfo->Object;
                if (sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->File, sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                }
            }

            if (sensitivityTriggerArr == nullptr)
            {
                if (result && sensitivityTriggerArrCount > 0)
                {
                    sensitivityTriggerArr = PARAMETER_NEW sensitivitySetting[sensitivityTriggerArrCount];
                    (void)pointerEntry->SetDupObject(sensitivityTriggerArr, sensitivityTriggerArrCount, file, line);
                }
                if (!result || sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate sensitivityTriggerArr\n");
                    }
                    sensitivityTriggerArrCount = 0;
                }
                for (UINT32 i = 0; result && i < sensitivityTriggerArrCount; i++)
                {
                    result = sensitivityTriggerArr[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (sensitivityTriggerArr == nullptr)
        {
            sensitivityTriggerArrCount = 0;
        }
    }

    // Reading Optional parameter topoSensitivityModifier from symbol table
    {
        SYMBOL_TABLE_ENTRY_READ(entry, result, topoSensitivityModifierExists, alignment)
        topoSensitivityModifierID = entry->ID;
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }
        if (result && topoSensitivityModifierExists)
        {
            if (result)
            {
                result = topoSensitivityModifier.Load(pointerEntry, alignment);
            }
        }
        else
        {
            PARAMETER_INITIALIZE(topoSensitivityModifier);
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixTopoPDAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixTopoPDAFType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(profileIndex);
    PARAMETER_INITIALIZE(defocusLow);
    PARAMETER_INITIALIZE(defocusHigh);
    PARAMETER_INITIALIZE(PDAFconfidence);
    PARAMETER_INITIALIZE(SADPanning);
    PARAMETER_INITIALIZE(gyroPanning);
    PARAMETER_INITIALIZE(motionPanning);
    PARAMETER_INITIALIZE(PDAFTopoReservedSensitivity);
    PARAMETER_INITIALIZE(sensitivityTriggerArr);
    PARAMETER_INITIALIZE(topoSensitivityModifierExists);
    PARAMETER_INITIALIZE(topoSensitivityModifier);

    result = afmonitorelements::ReadEnum_chromatixTopoPDAFEnum(entry, profileIndex, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusHigh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, PDAFconfidence, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, SADPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyroPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, motionPanning, alignment)

    // Reading Array PDAFTopoReservedSensitivity from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        PDAFTopoReservedSensitivityCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, PDAFTopoReservedSensitivityCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            PDAFTopoReservedSensitivityID = pointerEntry->ID;
            DupObjInfo* PDAFTopoReservedSensitivityDupInfo = pointerEntry->GetDupObject(PDAFTopoReservedSensitivityCount, file, line);
            if (PDAFTopoReservedSensitivityDupInfo != nullptr && PDAFTopoReservedSensitivityDupInfo->Object != nullptr)
            {
                PDAFTopoReservedSensitivity = (INT32*)PDAFTopoReservedSensitivityDupInfo->Object;
                if (PDAFTopoReservedSensitivity == nullptr)
                {
                    if (PDAFTopoReservedSensitivityDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "PDAFTopoReservedSensitivity duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            PDAFTopoReservedSensitivityDupInfo->File, PDAFTopoReservedSensitivityDupInfo->Line, PDAFTopoReservedSensitivityDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "PDAFTopoReservedSensitivity duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            PDAFTopoReservedSensitivityDupInfo->Line, PDAFTopoReservedSensitivityDupInfo->RefCount);
                    }
                }
            }

            if (PDAFTopoReservedSensitivity == nullptr)
            {
                if (result && PDAFTopoReservedSensitivityCount > 0)
                {
                    PDAFTopoReservedSensitivity = pointerEntry->ReadArray<INT32>(PDAFTopoReservedSensitivityCount, alignment);
                    result = PDAFTopoReservedSensitivity != nullptr;
                }
                if (!result || PDAFTopoReservedSensitivity == nullptr)
                {
                    if (PDAFTopoReservedSensitivityCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate PDAFTopoReservedSensitivity\n");
                    }
                    PDAFTopoReservedSensitivityCount = 0;
                }
            }
        }
        if (PDAFTopoReservedSensitivity == nullptr)
        {
            PDAFTopoReservedSensitivityCount = 0;
        }
    }

    // Reading Array sensitivityTriggerArr from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        sensitivityTriggerArrCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, sensitivityTriggerArrCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            sensitivityTriggerArrID = pointerEntry->ID;
            DupObjInfo* sensitivityTriggerArrDupInfo = pointerEntry->GetDupObject(sensitivityTriggerArrCount, file, line);
            if (sensitivityTriggerArrDupInfo != nullptr && sensitivityTriggerArrDupInfo->Object != nullptr)
            {
                sensitivityTriggerArr = (sensitivitySetting*)sensitivityTriggerArrDupInfo->Object;
                if (sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->File, sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                }
            }

            if (sensitivityTriggerArr == nullptr)
            {
                if (result && sensitivityTriggerArrCount > 0)
                {
                    sensitivityTriggerArr = PARAMETER_NEW sensitivitySetting[sensitivityTriggerArrCount];
                    (void)pointerEntry->SetDupObject(sensitivityTriggerArr, sensitivityTriggerArrCount, file, line);
                }
                if (!result || sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate sensitivityTriggerArr\n");
                    }
                    sensitivityTriggerArrCount = 0;
                }
                for (UINT32 i = 0; result && i < sensitivityTriggerArrCount; i++)
                {
                    result = sensitivityTriggerArr[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (sensitivityTriggerArr == nullptr)
        {
            sensitivityTriggerArrCount = 0;
        }
    }

    // Reading Optional parameter topoSensitivityModifier from symbol table
    {
        SYMBOL_TABLE_ENTRY_READ(entry, result, topoSensitivityModifierExists, alignment)
        topoSensitivityModifierID = entry->ID;
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }
        if (result && topoSensitivityModifierExists)
        {
            if (result)
            {
                result = topoSensitivityModifier.Load(pointerEntry, alignment);
            }
        }
        else
        {
            PARAMETER_INITIALIZE(topoSensitivityModifier);
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixTopoCAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixTopoCAFType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(profileIndex);
    PARAMETER_INITIALIZE(SADR);
    PARAMETER_INITIALIZE(gyro);
    PARAMETER_INITIALIZE(motion);
    PARAMETER_INITIALIZE(gyroPanning);
    PARAMETER_INITIALIZE(motionPanning);
    PARAMETER_INITIALIZE(SADPanning);
    PARAMETER_INITIALIZE(FV);
    PARAMETER_INITIALIZE(faceTriggerHold);
    PARAMETER_INITIALIZE(CAFSceneChangeHold);
    PARAMETER_INITIALIZE(CAFTopoReservedSensitivity);
    PARAMETER_INITIALIZE(sensitivityTriggerArr);
    PARAMETER_INITIALIZE(topoSensitivityModifierExists);
    PARAMETER_INITIALIZE(topoSensitivityModifier);

    result = afmonitorelements::ReadEnum_chromatixTopoCAFEnum(entry, profileIndex, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, SADR, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyro, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, motion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyroPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, motionPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, SADPanning, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FV, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, faceTriggerHold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, CAFSceneChangeHold, alignment)

    // Reading Array CAFTopoReservedSensitivity from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        CAFTopoReservedSensitivityCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, CAFTopoReservedSensitivityCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            CAFTopoReservedSensitivityID = pointerEntry->ID;
            DupObjInfo* CAFTopoReservedSensitivityDupInfo = pointerEntry->GetDupObject(CAFTopoReservedSensitivityCount, file, line);
            if (CAFTopoReservedSensitivityDupInfo != nullptr && CAFTopoReservedSensitivityDupInfo->Object != nullptr)
            {
                CAFTopoReservedSensitivity = (INT32*)CAFTopoReservedSensitivityDupInfo->Object;
                if (CAFTopoReservedSensitivity == nullptr)
                {
                    if (CAFTopoReservedSensitivityDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "CAFTopoReservedSensitivity duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            CAFTopoReservedSensitivityDupInfo->File, CAFTopoReservedSensitivityDupInfo->Line, CAFTopoReservedSensitivityDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "CAFTopoReservedSensitivity duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            CAFTopoReservedSensitivityDupInfo->Line, CAFTopoReservedSensitivityDupInfo->RefCount);
                    }
                }
            }

            if (CAFTopoReservedSensitivity == nullptr)
            {
                if (result && CAFTopoReservedSensitivityCount > 0)
                {
                    CAFTopoReservedSensitivity = pointerEntry->ReadArray<INT32>(CAFTopoReservedSensitivityCount, alignment);
                    result = CAFTopoReservedSensitivity != nullptr;
                }
                if (!result || CAFTopoReservedSensitivity == nullptr)
                {
                    if (CAFTopoReservedSensitivityCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate CAFTopoReservedSensitivity\n");
                    }
                    CAFTopoReservedSensitivityCount = 0;
                }
            }
        }
        if (CAFTopoReservedSensitivity == nullptr)
        {
            CAFTopoReservedSensitivityCount = 0;
        }
    }

    // Reading Array sensitivityTriggerArr from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        sensitivityTriggerArrCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, sensitivityTriggerArrCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            sensitivityTriggerArrID = pointerEntry->ID;
            DupObjInfo* sensitivityTriggerArrDupInfo = pointerEntry->GetDupObject(sensitivityTriggerArrCount, file, line);
            if (sensitivityTriggerArrDupInfo != nullptr && sensitivityTriggerArrDupInfo->Object != nullptr)
            {
                sensitivityTriggerArr = (sensitivitySetting*)sensitivityTriggerArrDupInfo->Object;
                if (sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->File, sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sensitivityTriggerArr duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            sensitivityTriggerArrDupInfo->Line, sensitivityTriggerArrDupInfo->RefCount);
                    }
                }
            }

            if (sensitivityTriggerArr == nullptr)
            {
                if (result && sensitivityTriggerArrCount > 0)
                {
                    sensitivityTriggerArr = PARAMETER_NEW sensitivitySetting[sensitivityTriggerArrCount];
                    (void)pointerEntry->SetDupObject(sensitivityTriggerArr, sensitivityTriggerArrCount, file, line);
                }
                if (!result || sensitivityTriggerArr == nullptr)
                {
                    if (sensitivityTriggerArrCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate sensitivityTriggerArr\n");
                    }
                    sensitivityTriggerArrCount = 0;
                }
                for (UINT32 i = 0; result && i < sensitivityTriggerArrCount; i++)
                {
                    result = sensitivityTriggerArr[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (sensitivityTriggerArr == nullptr)
        {
            sensitivityTriggerArrCount = 0;
        }
    }

    // Reading Optional parameter topoSensitivityModifier from symbol table
    {
        SYMBOL_TABLE_ENTRY_READ(entry, result, topoSensitivityModifierExists, alignment)
        topoSensitivityModifierID = entry->ID;
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }
        if (result && topoSensitivityModifierExists)
        {
            if (result)
            {
                result = topoSensitivityModifier.Load(pointerEntry, alignment);
            }
        }
        else
        {
            PARAMETER_INITIALIZE(topoSensitivityModifier);
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixMonitorAlgoConfigType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixMonitorAlgoConfigType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(topoCAF);
    PARAMETER_INITIALIZE(topoPDAF);
    PARAMETER_INITIALIZE(topoTOF);
    PARAMETER_INITIALIZE(topoDefaultMixer);
    PARAMETER_INITIALIZE(topoDepthAF);
    PARAMETER_INITIALIZE(globalSensitivityModifierExists);
    PARAMETER_INITIALIZE(globalSensitivityModifier);
    PARAMETER_INITIALIZE(topoAlgUtil);

    result = topoCAF.Load(entry, alignment);
    if (result)
    {
        result = topoPDAF.Load(entry, alignment);
    }
    if (result)
    {
        result = topoTOF.Load(entry, alignment);
    }
    if (result)
    {
        result = topoDefaultMixer.Load(entry, alignment);
    }
    if (result)
    {
        result = topoDepthAF.Load(entry, alignment);
    }

    // Reading Optional parameter globalSensitivityModifier from symbol table
    {
        SYMBOL_TABLE_ENTRY_READ(entry, result, globalSensitivityModifierExists, alignment)
        globalSensitivityModifierID = entry->ID;
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }
        if (result && globalSensitivityModifierExists)
        {
            if (result)
            {
                result = globalSensitivityModifier.Load(pointerEntry, alignment);
            }
        }
        else
        {
            PARAMETER_INITIALIZE(globalSensitivityModifier);
        }
    }
    if (result)
    {
        result = topoAlgUtil.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixAFMONITORType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixAFMONITORType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(monitorAlgoConfig);
    PARAMETER_INITIALIZE(valueMonitorBank);

    result = module_version.Load(entry, alignment);
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = monitorAlgoConfig.Load(entry, alignment);
    }
    if (result)
    {
        result = valueMonitorBank.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixAFMONITORType::module_versionStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(major_revision);
    PARAMETER_INITIALIZE(minor_revision);
    PARAMETER_INITIALIZE(incr_revision);

    SYMBOL_TABLE_ENTRY_READ(entry, result, major_revision, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minor_revision, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, incr_revision, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load parameter_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixAFMONITORType::parameter_versionStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(revision);


    // Reading String revision from symbol table
    {
        UINT32 count = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, count, alignment)
        ParameterFileSymbolTableEntry stringPointerEntryCls;
        ParameterFileSymbolTableEntry* const stringPointerEntry = &stringPointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(stringPointerEntryCls, entry, alignment);
        }
        SYMBOL_TABLE_ENTRY_READ_STRING(stringPointerEntry, result, revision, count, alignment)
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixValueMonitorBankType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixValueMonitorBankType::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(valueMonitor))
    {
        PARAMETER_DELETE[] valueMonitor;
    }
    valueMonitor = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload sensitivityModifierArr
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void sensitivityModifierArr::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(roiBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] roiBasedSensitivityModifier;
    }
    roiBasedSensitivityModifier = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(zoomBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] zoomBasedSensitivityModifier;
    }
    zoomBasedSensitivityModifier = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(gainBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] gainBasedSensitivityModifier;
    }
    gainBasedSensitivityModifier = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload sensitivitySetting
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void sensitivitySetting::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(sensitivityTriggerSet))
    {
        PARAMETER_DELETE[] sensitivityTriggerSet;
    }
    sensitivityTriggerSet = nullptr;
    VMSensitivityModifier.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixTopoAlgUtilType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixTopoAlgUtilType::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < sensitivityTriggerArrCount; i++)
    {
        sensitivityTriggerArr[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(sensitivityTriggerArr))
    {
        PARAMETER_DELETE[] sensitivityTriggerArr;
    }
    sensitivityTriggerArr = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixTopoDepthAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixTopoDepthAFType::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(DepthAFTopoReservedSensitivity))
    {
        PARAMETER_DELETE[] DepthAFTopoReservedSensitivity;
    }
    DepthAFTopoReservedSensitivity = nullptr;
    for (UINT32 i = 0; i < sensitivityTriggerArrCount; i++)
    {
        sensitivityTriggerArr[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(sensitivityTriggerArr))
    {
        PARAMETER_DELETE[] sensitivityTriggerArr;
    }
    sensitivityTriggerArr = nullptr;
    topoSensitivityModifier.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixTopoDefaultMixerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixTopoDefaultMixerType::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; i < sensitivityTriggerArrCount; i++)
    {
        sensitivityTriggerArr[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(sensitivityTriggerArr))
    {
        PARAMETER_DELETE[] sensitivityTriggerArr;
    }
    sensitivityTriggerArr = nullptr;
    topoSensitivityModifier.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixTopoTOFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixTopoTOFType::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(TOFTopoReservedSensitivity))
    {
        PARAMETER_DELETE[] TOFTopoReservedSensitivity;
    }
    TOFTopoReservedSensitivity = nullptr;
    for (UINT32 i = 0; i < sensitivityTriggerArrCount; i++)
    {
        sensitivityTriggerArr[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(sensitivityTriggerArr))
    {
        PARAMETER_DELETE[] sensitivityTriggerArr;
    }
    sensitivityTriggerArr = nullptr;
    topoSensitivityModifier.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixTopoPDAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixTopoPDAFType::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(PDAFTopoReservedSensitivity))
    {
        PARAMETER_DELETE[] PDAFTopoReservedSensitivity;
    }
    PDAFTopoReservedSensitivity = nullptr;
    for (UINT32 i = 0; i < sensitivityTriggerArrCount; i++)
    {
        sensitivityTriggerArr[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(sensitivityTriggerArr))
    {
        PARAMETER_DELETE[] sensitivityTriggerArr;
    }
    sensitivityTriggerArr = nullptr;
    topoSensitivityModifier.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixTopoCAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixTopoCAFType::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(CAFTopoReservedSensitivity))
    {
        PARAMETER_DELETE[] CAFTopoReservedSensitivity;
    }
    CAFTopoReservedSensitivity = nullptr;
    for (UINT32 i = 0; i < sensitivityTriggerArrCount; i++)
    {
        sensitivityTriggerArr[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(sensitivityTriggerArr))
    {
        PARAMETER_DELETE[] sensitivityTriggerArr;
    }
    sensitivityTriggerArr = nullptr;
    topoSensitivityModifier.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixMonitorAlgoConfigType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixMonitorAlgoConfigType::Unload(ParameterFileSymbolTable* const __table)
{
    topoCAF.Unload(__table);
    topoPDAF.Unload(__table);
    topoTOF.Unload(__table);
    topoDefaultMixer.Unload(__table);
    topoDepthAF.Unload(__table);
    globalSensitivityModifier.Unload(__table);
    topoAlgUtil.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixAFMONITORType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixAFMONITORType::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    monitorAlgoConfig.Unload(__table);
    valueMonitorBank.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload parameter_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixAFMONITORType::parameter_versionStruct::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(revision))
    {
        PARAMETER_DELETE[] revision;
    }
    revision = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Release the ParameterModule object
/// Requires that this object was created via a ParameterSetManager::GetModule call
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixAFMONITORType::Release()
{
    ((chromatixAFMONITORTypeClass*)this)->Release();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Returns the ParameterModule::Modified value
/// The Modified value is incremented when the module's data or pointer values change
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
UINT32 chromatixAFMONITORType::GetModified()
{
    return ((chromatixAFMONITORTypeClass*)this)->Modified;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Create module, and return a new object
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ParameterModule* chromatixAFMONITORTypeClass::Create(
    ModuleData*    moduleData,
    DefaultModule* const defModule) const
{
    chromatixAFMONITORTypeClass* cls = nullptr;

    if (PARAMETER_STRCMP(Type, moduleData->Type) == 0 && Version.Value == moduleData->Version.Value)
    {
        const UINT32 id = moduleData->DuplicateID > 0 ? moduleData->DuplicateID : moduleData->ID;

        ParameterModule* const module = defModule->Find(id);
        if (module != nullptr)
        {
            cls = (chromatixAFMONITORTypeClass*)module;
        }
        else
        {
            cls = PARAMETER_NEW chromatixAFMONITORTypeClass(GetName(moduleData->Type), moduleData);
            cls->SymbolTableID = id;
            defModule->AddModule((ParameterModule*)cls);
        }
    }
    else if (Version.Value != moduleData->Version.Value)
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatixAFMONITORTypeClass, binary version (%lld) does not match source version (%lld)\n",
            moduleData->Version.Value, Version.Value);
    }
    else
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatixAFMONITORTypeClass, binary name (%s) does not match source name (%s)\n",
            moduleData->Type, Type);
    }

    return (ParameterModule*)cls;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module data, return true is successful
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixAFMONITORTypeClass::LoadModule(
    ParameterFileSymbolTable* const table)
{
    bool result = true;

    if (!Loaded)
    {
        BYTE const alignment = table->Alignment;
        chromatixAFMONITORTypeClass* const cls = this;

        ParameterFileSymbolTableEntry  entryObj;
        ParameterFileSymbolTableEntry* const entry = &entryObj;
        // With EzTune enabled, the unused upper byte of SymbolTableID value can change, so clear it
        result = table->Find(entryObj, SymbolTableID & 0x00ffffff);

        if (!result)
        {
            PARAMETER_LOG_ERROR(entry->SetManager, "chromatixAFMONITORTypeClass::LoadModule Failed to find module ID (%d) in Symbol Table\n", SymbolTableID);
        }

        if (result)
        {
            result = cls->Load(entry, alignment);
        }
        Modified++;
        Loaded = true;
    }

    if (!result)
    {
        /// Module failed to fully load, unload it
        UnloadModule();
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload module data
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixAFMONITORTypeClass::UnloadModule()
{
    if (Loaded)
    {
        if (Data != nullptr && Data->SymbolTable != nullptr)
        {
            Unload(Data->SymbolTable);
        }
        else
        {
            PARAMETER_LOG_ERROR(Data != nullptr ? Data->SetManager : nullptr, "UnloadModule %s called with nullptr "
                "Data->SymbolTable object\n", Name);
            Unload(nullptr);
        }
        Loaded = false;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// /// Release the ParameterModule object
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixAFMONITORTypeClass::Release()
{
    ParameterModule::Release();
}

AFMONITORELEMENTS_NAMESPACE_END
