////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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  afpdafelements.cpp
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "afpdafelements.h"
#include "parametersetmanager.h"

AFPDAFELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixPDAFROISelection::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, "type") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)type, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lowConfidenceMultiplier") == 0)
    {
        ParameterUtils::DoubleToString((double)lowConfidenceMultiplier, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "highConfidenceMultiplier") == 0)
    {
        ParameterUtils::DoubleToString((double)highConfidenceMultiplier, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDAFROISelection::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, "type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            type = (afglobalelements::AFTriggerCtrlTypeROIEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lowConfidenceMultiplier") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lowConfidenceMultiplier = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "highConfidenceMultiplier") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            highConfidenceMultiplier = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDAFROISelection::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);

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

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

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

    return __result;
}

bool chromatixPDAFTemporalFilterSettingType::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, "gainThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)gainThreshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confidenceWeightLUT") == 0)
    {
        __result = confidenceWeightLUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lensMoveWeightLUT") == 0)
    {
        __result = lensMoveWeightLUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayWeight") == 0)
    {
        __result = frameDelayWeight.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDAFTemporalFilterSettingType::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, "gainThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gainThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidenceWeightLUT") == 0)
    {
        __result = confidenceWeightLUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lensMoveWeightLUT") == 0)
    {
        __result = lensMoveWeightLUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayWeight") == 0)
    {
        __result = frameDelayWeight.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDAFTemporalFilterSettingType::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);

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

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

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

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

    return __result;
}

bool chromatixPDAFTemporalFilterSettingType::frameDelayWeightStruct::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, "weights") == 0)
    {
        if (__index < weightsCount)
        {
            ParameterUtils::DoubleToString((double)weights[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < weightsCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)weights[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool chromatixPDAFTemporalFilterSettingType::frameDelayWeightStruct::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, "weights") == 0)
    {
        if (__index < weightsCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                weights[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    weights[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }

    return __result;
}

bool chromatixPDAFTemporalFilterSettingType::frameDelayWeightStruct::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);

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

    return __result;
}

bool chromatixPDAFTemporalFilterType::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, "setting") == 0)
    {
        if (__index < settingCount)
        {
            __result = setting[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDAFTemporalFilterType::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, "setting") == 0)
    {
        if (__index < settingCount)
        {
            __result = setting[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDAFTemporalFilterType::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);

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

    return __result;
}

bool chromatixPDMotionConvergeScalerEntryType::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, "motion") == 0)
    {
        ParameterUtils::DoubleToString((double)motion, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "scaler") == 0)
    {
        ParameterUtils::DoubleToString((double)scaler, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDMotionConvergeScalerEntryType::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, "motion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            motion = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "scaler") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            scaler = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDMotionConvergeScalerEntryType::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);

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

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

    return __result;
}

bool chromatixPDMotionConvergeType::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, "motionConvergeEntries") == 0)
    {
        if (__index < motionConvergeEntriesCount)
        {
            __result = motionConvergeEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDMotionConvergeType::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, "motionConvergeEntries") == 0)
    {
        if (__index < motionConvergeEntriesCount)
        {
            __result = motionConvergeEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDMotionConvergeType::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);

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

    return __result;
}

bool chromatixMLPDControlType::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, "enableMLPD") == 0)
    {
        ParameterUtils::DoubleToString((double)enableMLPD, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixMLPDControlType::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, "enableMLPD") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableMLPD = (BOOL)dblValue; 
        }
    }

    return __result;
}

bool chromatixMLPDControlType::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);

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

    return __result;
}

bool chromatixPDFocusTableEntryType::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, "defocus") == 0)
    {
        ParameterUtils::DoubleToString((double)defocus, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "movePercent") == 0)
    {
        ParameterUtils::DoubleToString((double)movePercent, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDFocusTableEntryType::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, "defocus") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocus = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "movePercent") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            movePercent = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDFocusTableEntryType::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);

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

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

    return __result;
}

bool chromatixPDFocusTableType::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, "focusEntries") == 0)
    {
        if (__index < focusEntriesCount)
        {
            __result = focusEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDFocusTableType::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, "focusEntries") == 0)
    {
        if (__index < focusEntriesCount)
        {
            __result = focusEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDFocusTableType::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);

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

    return __result;
}

bool chromatixAdvancedSparsePDControlType::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, "enableForSparsePD") == 0)
    {
        ParameterUtils::DoubleToString((double)enableForSparsePD, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "skipFineScan") == 0)
    {
        ParameterUtils::DoubleToString((double)skipFineScan, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "focusDoneThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)focusDoneThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "focusTable") == 0)
    {
        __result = focusTable.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixAdvancedSparsePDControlType::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, "enableForSparsePD") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableForSparsePD = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "skipFineScan") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            skipFineScan = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "focusDoneThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            focusDoneThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "focusTable") == 0)
    {
        __result = focusTable.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixAdvancedSparsePDControlType::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);

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

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

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

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

    return __result;
}

bool chromatixPDForceEnterFineSearchType::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, "directionReverseCountThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)directionReverseCountThreshold, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDForceEnterFineSearchType::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "directionReverseCountThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            directionReverseCountThreshold = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDForceEnterFineSearchType::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

    return __result;
}

bool chromaitxPDConvergeDoneFilterType::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, "length") == 0)
    {
        ParameterUtils::DoubleToString((double)length, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)threshold, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromaitxPDConvergeDoneFilterType::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "length") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            length = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            threshold = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromaitxPDConvergeDoneFilterType::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

    return __result;
}

bool chromatixPDSaliencyControlType::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, "saliencyROIProcess") == 0)
    {
        __result = saliencyROIProcess.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "minMoveThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)minMoveThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusFilter") == 0)
    {
        __result = defocusFilter.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "fallback") == 0)
    {
        __result = fallback.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDSaliencyControlType::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, "saliencyROIProcess") == 0)
    {
        __result = saliencyROIProcess.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "minMoveThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minMoveThreshold = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusFilter") == 0)
    {
        __result = defocusFilter.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "fallback") == 0)
    {
        __result = fallback.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDSaliencyControlType::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);

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

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

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

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

    return __result;
}

bool chromatixPDSaliencyControlType::saliencyROIProcessStruct::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, "saliencyROIRoughStable") == 0)
    {
        __result = saliencyROIRoughStable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "saliencyROIStrictStable") == 0)
    {
        __result = saliencyROIStrictStable.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDSaliencyControlType::saliencyROIProcessStruct::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, "saliencyROIRoughStable") == 0)
    {
        __result = saliencyROIRoughStable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "saliencyROIStrictStable") == 0)
    {
        __result = saliencyROIStrictStable.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDSaliencyControlType::saliencyROIProcessStruct::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);

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

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

    return __result;
}

bool chromatixPDSaliencyControlType::defocusFilterStruct::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, "length") == 0)
    {
        ParameterUtils::DoubleToString((double)length, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confidenceHighThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)confidenceHighThreshold, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDSaliencyControlType::defocusFilterStruct::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "length") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            length = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidenceHighThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confidenceHighThreshold = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDSaliencyControlType::defocusFilterStruct::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

    return __result;
}

bool chromatixPDSaliencyControlType::fallbackStruct::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, "fallbackROISizeThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)fallbackROISizeThreshold, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDSaliencyControlType::fallbackStruct::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fallbackROISizeThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fallbackROISizeThreshold = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDSaliencyControlType::fallbackStruct::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

    return __result;
}

bool chromatixPDTrackControlType::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, "trackROIProcess") == 0)
    {
        __result = trackROIProcess.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "minMoveThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)minMoveThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusFilter") == 0)
    {
        __result = defocusFilter.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "fallback") == 0)
    {
        __result = fallback.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDTrackControlType::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, "trackROIProcess") == 0)
    {
        __result = trackROIProcess.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "minMoveThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minMoveThreshold = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusFilter") == 0)
    {
        __result = defocusFilter.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "fallback") == 0)
    {
        __result = fallback.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDTrackControlType::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);

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

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

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

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

    return __result;
}

bool chromatixPDTrackControlType::trackROIProcessStruct::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, "trackROIRoughStable") == 0)
    {
        __result = trackROIRoughStable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "trackROIStrictStable") == 0)
    {
        __result = trackROIStrictStable.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDTrackControlType::trackROIProcessStruct::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, "trackROIRoughStable") == 0)
    {
        __result = trackROIRoughStable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "trackROIStrictStable") == 0)
    {
        __result = trackROIStrictStable.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDTrackControlType::trackROIProcessStruct::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);

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

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

    return __result;
}

bool chromatixPDTrackControlType::defocusFilterStruct::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, "length") == 0)
    {
        ParameterUtils::DoubleToString((double)length, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confidenceHighThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)confidenceHighThreshold, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDTrackControlType::defocusFilterStruct::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "length") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            length = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidenceHighThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confidenceHighThreshold = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDTrackControlType::defocusFilterStruct::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

    return __result;
}

bool chromatixPDTrackControlType::fallbackStruct::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, "fallbackROISizeThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)fallbackROISizeThreshold, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDTrackControlType::fallbackStruct::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fallbackROISizeThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fallbackROISizeThreshold = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDTrackControlType::fallbackStruct::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

    return __result;
}

bool chromatixPDTouchControlType::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, "offCenterThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)offCenterThreshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "skipSearchIfSceneInFocus") == 0)
    {
        ParameterUtils::DoubleToString((double)skipSearchIfSceneInFocus, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDTouchControlType::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, "offCenterThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            offCenterThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "skipSearchIfSceneInFocus") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            skipSearchIfSceneInFocus = (globalelements::enable_flag_type)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDTouchControlType::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);

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

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

    return __result;
}

bool chromatixPDFaceControlType::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, "faceROIProcess") == 0)
    {
        __result = faceROIProcess.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "minMoveThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)minMoveThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ROIMoveConvergeSuppress") == 0)
    {
        __result = ROIMoveConvergeSuppress.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "defocusFilter") == 0)
    {
        __result = defocusFilter.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "fallback") == 0)
    {
        __result = fallback.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "faceChangeRefocusTrigger") == 0)
    {
        __result = faceChangeRefocusTrigger.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDFaceControlType::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, "faceROIProcess") == 0)
    {
        __result = faceROIProcess.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "minMoveThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minMoveThreshold = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROIMoveConvergeSuppress") == 0)
    {
        __result = ROIMoveConvergeSuppress.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "defocusFilter") == 0)
    {
        __result = defocusFilter.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "fallback") == 0)
    {
        __result = fallback.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "faceChangeRefocusTrigger") == 0)
    {
        __result = faceChangeRefocusTrigger.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDFaceControlType::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);

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

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

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

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

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

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

    return __result;
}

bool chromatixPDFaceControlType::faceROIProcessStruct::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, "ROIProcessEnable") == 0)
    {
        ParameterUtils::DoubleToString((double)ROIProcessEnable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ROIRoughStable") == 0)
    {
        __result = ROIRoughStable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "ROIStrictStable") == 0)
    {
        __result = ROIStrictStable.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDFaceControlType::faceROIProcessStruct::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, "ROIProcessEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROIProcessEnable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROIRoughStable") == 0)
    {
        __result = ROIRoughStable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "ROIStrictStable") == 0)
    {
        __result = ROIStrictStable.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDFaceControlType::faceROIProcessStruct::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);

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

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

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

    return __result;
}

bool chromatixPDFaceControlType::ROIMoveConvergeSuppressStruct::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, "stableCountThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)stableCountThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "moveThresholdInX") == 0)
    {
        ParameterUtils::DoubleToString((double)moveThresholdInX, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "moveThresholdInY") == 0)
    {
        ParameterUtils::DoubleToString((double)moveThresholdInY, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDFaceControlType::ROIMoveConvergeSuppressStruct::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stableCountThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stableCountThreshold = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "moveThresholdInX") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            moveThresholdInX = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "moveThresholdInY") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            moveThresholdInY = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDFaceControlType::ROIMoveConvergeSuppressStruct::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

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

    return __result;
}

bool chromatixPDFaceControlType::defocusFilterStruct::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, "length") == 0)
    {
        ParameterUtils::DoubleToString((double)length, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confidenceHighThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)confidenceHighThreshold, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDFaceControlType::defocusFilterStruct::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "length") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            length = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidenceHighThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confidenceHighThreshold = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDFaceControlType::defocusFilterStruct::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

    return __result;
}

bool chromatixPDFaceControlType::fallbackStruct::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, "fallbackROISizeThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)fallbackROISizeThreshold, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDFaceControlType::fallbackStruct::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fallbackROISizeThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fallbackROISizeThreshold = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDFaceControlType::fallbackStruct::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

    return __result;
}

bool chromatixPDFaceControlType::faceChangeRefocusTriggerStruct::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, "roiChangeThreshPercentage") == 0)
    {
        ParameterUtils::DoubleToString((double)roiChangeThreshPercentage, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "roiSizeStableThresh") == 0)
    {
        ParameterUtils::DoubleToString((double)roiSizeStableThresh, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDFaceControlType::faceChangeRefocusTriggerStruct::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 = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiChangeThreshPercentage") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            roiChangeThreshPercentage = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiSizeStableThresh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            roiSizeStableThresh = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDFaceControlType::faceChangeRefocusTriggerStruct::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::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

    return __result;
}

bool chromatixlensPosIntervalListEntriesType::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, "lpInterval") == 0)
    {
        ParameterUtils::DoubleToString((double)lpInterval, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixlensPosIntervalListEntriesType::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, "lpInterval") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lpInterval = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixlensPosIntervalListEntriesType::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);

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

    return __result;
}

bool chromatixlensPosIntervalListType::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, "lensPosIntervalListEntries") == 0)
    {
        if (__index < lensPosIntervalListEntriesCount)
        {
            __result = lensPosIntervalListEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixlensPosIntervalListType::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, "lensPosIntervalListEntries") == 0)
    {
        if (__index < lensPosIntervalListEntriesCount)
        {
            __result = lensPosIntervalListEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixlensPosIntervalListType::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);

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

    return __result;
}

bool chromatixluxNodeListEntriesType::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, "luxIndex") == 0)
    {
        ParameterUtils::DoubleToString((double)luxIndex, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixluxNodeListEntriesType::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, "luxIndex") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            luxIndex = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixluxNodeListEntriesType::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);

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

    return __result;
}

bool chromatixluxNodeListType::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, "luxNodeListEntries") == 0)
    {
        if (__index < luxNodeListEntriesCount)
        {
            __result = luxNodeListEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixluxNodeListType::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, "luxNodeListEntries") == 0)
    {
        if (__index < luxNodeListEntriesCount)
        {
            __result = luxNodeListEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixluxNodeListType::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);

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

    return __result;
}

bool chromatixAdaptivePDOffsetCorrectionType::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, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minSampleRequired") == 0)
    {
        ParameterUtils::DoubleToString((double)minSampleRequired, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxSampleCount") == 0)
    {
        ParameterUtils::DoubleToString((double)maxSampleCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableOutlierRemoval") == 0)
    {
        ParameterUtils::DoubleToString((double)enableOutlierRemoval, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "outlierRemovalRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)outlierRemovalRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pdSampleConfThresholdMin") == 0)
    {
        ParameterUtils::DoubleToString((double)pdSampleConfThresholdMin, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "interpolateDistance") == 0)
    {
        ParameterUtils::DoubleToString((double)interpolateDistance, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "recollectSampleTimeThres") == 0)
    {
        ParameterUtils::DoubleToString((double)recollectSampleTimeThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxFinesearchFrameCount") == 0)
    {
        ParameterUtils::DoubleToString((double)maxFinesearchFrameCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableFastStartMode") == 0)
    {
        ParameterUtils::DoubleToString((double)enableFastStartMode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusOffsetMin") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusOffsetMin, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusOffsetMax") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusOffsetMax, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayCount") == 0)
    {
        ParameterUtils::DoubleToString((double)frameDelayCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxSlope") == 0)
    {
        ParameterUtils::DoubleToString((double)maxSlope, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minDistributionScore") == 0)
    {
        ParameterUtils::DoubleToString((double)minDistributionScore, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numTemperatureNode") == 0)
    {
        ParameterUtils::DoubleToString((double)numTemperatureNode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minTemp") == 0)
    {
        ParameterUtils::DoubleToString((double)minTemp, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxTemp") == 0)
    {
        ParameterUtils::DoubleToString((double)maxTemp, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diffusionRatio1") == 0)
    {
        ParameterUtils::DoubleToString((double)diffusionRatio1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diffusionRatio2") == 0)
    {
        ParameterUtils::DoubleToString((double)diffusionRatio2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "mapWidth") == 0)
    {
        ParameterUtils::DoubleToString((double)mapWidth, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "mapHeight") == 0)
    {
        ParameterUtils::DoubleToString((double)mapHeight, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minGridMapOverlapRatio1") == 0)
    {
        ParameterUtils::DoubleToString((double)minGridMapOverlapRatio1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minGridMapOverlapRatio2") == 0)
    {
        ParameterUtils::DoubleToString((double)minGridMapOverlapRatio2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "scGyroThres") == 0)
    {
        ParameterUtils::DoubleToString((double)scGyroThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "scMVThres") == 0)
    {
        ParameterUtils::DoubleToString((double)scMVThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "luxNodeList") == 0)
    {
        __result = luxNodeList.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lensPosIntervalList") == 0)
    {
        __result = lensPosIntervalList.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixAdaptivePDOffsetCorrectionType::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, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minSampleRequired") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minSampleRequired = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxSampleCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxSampleCount = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableOutlierRemoval") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableOutlierRemoval = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "outlierRemovalRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            outlierRemovalRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pdSampleConfThresholdMin") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pdSampleConfThresholdMin = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "interpolateDistance") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            interpolateDistance = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "recollectSampleTimeThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            recollectSampleTimeThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxFinesearchFrameCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxFinesearchFrameCount = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableFastStartMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFastStartMode = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusOffsetMin") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusOffsetMin = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusOffsetMax") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusOffsetMax = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameDelayCount = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxSlope") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxSlope = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minDistributionScore") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minDistributionScore = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numTemperatureNode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numTemperatureNode = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minTemp") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minTemp = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxTemp") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxTemp = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diffusionRatio1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diffusionRatio1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diffusionRatio2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diffusionRatio2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "mapWidth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            mapWidth = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "mapHeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            mapHeight = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minGridMapOverlapRatio1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minGridMapOverlapRatio1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minGridMapOverlapRatio2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minGridMapOverlapRatio2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "scGyroThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            scGyroThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "scMVThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            scMVThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "luxNodeList") == 0)
    {
        __result = luxNodeList.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lensPosIntervalList") == 0)
    {
        __result = lensPosIntervalList.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixAdaptivePDOffsetCorrectionType::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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatixPDMultiwindowType::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, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "HNumWindows") == 0)
    {
        ParameterUtils::DoubleToString((double)HNumWindows, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "VNumWindows") == 0)
    {
        ParameterUtils::DoubleToString((double)VNumWindows, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "PDPercentile") == 0)
    {
        ParameterUtils::DoubleToString((double)PDPercentile, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confidenceThMultiple") == 0)
    {
        ParameterUtils::DoubleToString((double)confidenceThMultiple, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "multiDepthDetect") == 0)
    {
        __result = multiDepthDetect.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lowLightDetect") == 0)
    {
        __result = lowLightDetect.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "lockToPeripheralDuringSearch") == 0)
    {
        ParameterUtils::DoubleToString((double)lockToPeripheralDuringSearch, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "activZoomControl") == 0)
    {
        __result = activZoomControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "saliencyMWTuning") == 0)
    {
        __result = saliencyMWTuning.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "motionMWTuning") == 0)
    {
        __result = motionMWTuning.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDMultiwindowType::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, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "HNumWindows") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            HNumWindows = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "VNumWindows") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            VNumWindows = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDPercentile") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            PDPercentile = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidenceThMultiple") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confidenceThMultiple = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "multiDepthDetect") == 0)
    {
        __result = multiDepthDetect.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lowLightDetect") == 0)
    {
        __result = lowLightDetect.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "lockToPeripheralDuringSearch") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lockToPeripheralDuringSearch = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "activZoomControl") == 0)
    {
        __result = activZoomControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "saliencyMWTuning") == 0)
    {
        __result = saliencyMWTuning.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "motionMWTuning") == 0)
    {
        __result = motionMWTuning.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDMultiwindowType::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);

    // 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));
    }

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatixPDMultiwindowType::multiDepthDetectStruct::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, "percentile") == 0)
    {
        ParameterUtils::DoubleToString((double)percentile, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "detectThLow") == 0)
    {
        ParameterUtils::DoubleToString((double)detectThLow, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "detectThHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)detectThHigh, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDMultiwindowType::multiDepthDetectStruct::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, "percentile") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            percentile = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "detectThLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            detectThLow = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "detectThHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            detectThHigh = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDMultiwindowType::multiDepthDetectStruct::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);

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

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

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

    return __result;
}

bool chromatixPDMultiwindowType::lowLightDetectStruct::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, "gainThLow") == 0)
    {
        ParameterUtils::DoubleToString((double)gainThLow, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gainThHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)gainThHigh, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDMultiwindowType::lowLightDetectStruct::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, "gainThLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gainThLow = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gainThHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gainThHigh = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDMultiwindowType::lowLightDetectStruct::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);

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

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

    return __result;
}

bool chromatixPDMultiwindowType::activZoomControlStruct::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, "zoomThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)zoomThreshold, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDMultiwindowType::activZoomControlStruct::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "zoomThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            zoomThreshold = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDMultiwindowType::activZoomControlStruct::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));
    }

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

    return __result;
}

bool chromatixPDMultiwindowType::saliencyMWTuningStruct::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, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "saliencyTh") == 0)
    {
        ParameterUtils::DoubleToString((double)saliencyTh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "saliencyStdTh") == 0)
    {
        ParameterUtils::DoubleToString((double)saliencyStdTh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "saliencyPriorityWeight") == 0)
    {
        ParameterUtils::DoubleToString((double)saliencyPriorityWeight, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "saliencyLUT") == 0)
    {
        __result = saliencyLUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "phaseDiffLUT") == 0)
    {
        __result = phaseDiffLUT.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "confidenceLUT") == 0)
    {
        __result = confidenceLUT.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDMultiwindowType::saliencyMWTuningStruct::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, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "saliencyTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            saliencyTh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "saliencyStdTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            saliencyStdTh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "saliencyPriorityWeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            saliencyPriorityWeight = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "saliencyLUT") == 0)
    {
        __result = saliencyLUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "phaseDiffLUT") == 0)
    {
        __result = phaseDiffLUT.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "confidenceLUT") == 0)
    {
        __result = confidenceLUT.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDMultiwindowType::saliencyMWTuningStruct::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);

    // 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));
    }

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

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

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

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

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

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

    return __result;
}

bool chromatixPDMultiwindowType::motionMWTuningStruct::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, "motionTh") == 0)
    {
        ParameterUtils::DoubleToString((double)motionTh, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDMultiwindowType::motionMWTuningStruct::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "motionTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            motionTh = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDMultiwindowType::motionMWTuningStruct::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));
    }

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

    return __result;
}

bool chromatixPDInternalType::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, "type") == 0)
    {
        ParameterUtils::DoubleToString((double)type, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "initialPosition") == 0)
    {
        ParameterUtils::DoubleToString((double)initialPosition, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "PDAFEnableFaceCAFPriority") == 0)
    {
        ParameterUtils::DoubleToString((double)PDAFEnableFaceCAFPriority, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "incDefocusThresholdPreviousError") == 0)
    {
        ParameterUtils::DoubleToString((double)incDefocusThresholdPreviousError, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fineScanRangeEnhance") == 0)
    {
        ParameterUtils::DoubleToString((double)fineScanRangeEnhance, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "softRegionThresholdMultiplier") == 0)
    {
        ParameterUtils::DoubleToString((double)softRegionThresholdMultiplier, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableSoftConfidenceThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)enableSoftConfidenceThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "softConfidenceThresholdDelta") == 0)
    {
        ParameterUtils::DoubleToString((double)softConfidenceThresholdDelta, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "softConfidenceFocus_pnt") == 0)
    {
        ParameterUtils::DoubleToString((double)softConfidenceFocus_pnt, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableSoftRegionThresholdHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)enableSoftRegionThresholdHigh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "softRegionThresholdHighMultiplier") == 0)
    {
        ParameterUtils::DoubleToString((double)softRegionThresholdHighMultiplier, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "softSceneChangeCount") == 0)
    {
        ParameterUtils::DoubleToString((double)softSceneChangeCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "cafStableFrameAllow") == 0)
    {
        __result = cafStableFrameAllow.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDInternalType::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, "type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            type = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "initialPosition") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            initialPosition = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDAFEnableFaceCAFPriority") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            PDAFEnableFaceCAFPriority = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "incDefocusThresholdPreviousError") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            incDefocusThresholdPreviousError = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fineScanRangeEnhance") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fineScanRangeEnhance = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "softRegionThresholdMultiplier") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            softRegionThresholdMultiplier = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableSoftConfidenceThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableSoftConfidenceThreshold = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "softConfidenceThresholdDelta") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            softConfidenceThresholdDelta = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "softConfidenceFocus_pnt") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            softConfidenceFocus_pnt = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableSoftRegionThresholdHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableSoftRegionThresholdHigh = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "softRegionThresholdHighMultiplier") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            softRegionThresholdHighMultiplier = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "softSceneChangeCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            softSceneChangeCount = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "cafStableFrameAllow") == 0)
    {
        __result = cafStableFrameAllow.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDInternalType::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);

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatixPDInternalType::cafStableFrameAllowStruct::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, "frameCount") == 0)
    {
        ParameterUtils::DoubleToString((double)frameCount, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDInternalType::cafStableFrameAllowStruct::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameCount = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDInternalType::cafStableFrameAllowStruct::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));
    }

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

    return __result;
}

bool chromatixPDPreprocessingType::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, "enableDoNotUseDefocusSampleByPD") == 0)
    {
        ParameterUtils::DoubleToString((double)enableDoNotUseDefocusSampleByPD, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableIncMinConfidenceThresholdByPD") == 0)
    {
        ParameterUtils::DoubleToString((double)enableIncMinConfidenceThresholdByPD, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "PDMaxLimitDoNotUseDefocusSample") == 0)
    {
        ParameterUtils::DoubleToString((double)PDMaxLimitDoNotUseDefocusSample, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "PDMaxLimitIncMinConfidenceThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)PDMaxLimitIncMinConfidenceThreshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "incMinConfidenceThresholdByPDScaler") == 0)
    {
        ParameterUtils::DoubleToString((double)incMinConfidenceThresholdByPDScaler, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDPreprocessingType::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableDoNotUseDefocusSampleByPD") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableDoNotUseDefocusSampleByPD = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableIncMinConfidenceThresholdByPD") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableIncMinConfidenceThresholdByPD = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDMaxLimitDoNotUseDefocusSample") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            PDMaxLimitDoNotUseDefocusSample = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "PDMaxLimitIncMinConfidenceThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            PDMaxLimitIncMinConfidenceThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "incMinConfidenceThresholdByPDScaler") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            incMinConfidenceThresholdByPDScaler = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDPreprocessingType::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));
    }

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

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

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

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

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

    return __result;
}

bool chromatixPDMonitorType::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, "waitConfidenceRecoverCount") == 0)
    {
        ParameterUtils::DoubleToString((double)waitConfidenceRecoverCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusedThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusedThreshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "depthStableThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)depthStableThreshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "defocusStableFilterLength") == 0)
    {
        ParameterUtils::DoubleToString((double)defocusStableFilterLength, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDMonitorType::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, "waitConfidenceRecoverCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            waitConfidenceRecoverCount = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusedThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusedThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "depthStableThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            depthStableThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "defocusStableFilterLength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            defocusStableFilterLength = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDMonitorType::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);

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

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

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

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

    return __result;
}

bool chromatixPDFocusScanType::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, "focusConvergeFrameSkip") == 0)
    {
        ParameterUtils::DoubleToString((double)focusConvergeFrameSkip, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableFineScan") == 0)
    {
        ParameterUtils::DoubleToString((double)enableFineScan, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minimumFineScanRange") == 0)
    {
        ParameterUtils::DoubleToString((double)minimumFineScanRange, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fineScanStepSize") == 0)
    {
        ParameterUtils::DoubleToString((double)fineScanStepSize, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "focusDoneThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)focusDoneThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableFineScanExtension") == 0)
    {
        ParameterUtils::DoubleToString((double)enableFineScanExtension, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "firstRunNotConfidenceAdd") == 0)
    {
        ParameterUtils::DoubleToString((double)firstRunNotConfidenceAdd, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDFocusScanType::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, "focusConvergeFrameSkip") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            focusConvergeFrameSkip = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableFineScan") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFineScan = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minimumFineScanRange") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minimumFineScanRange = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fineScanStepSize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fineScanStepSize = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "focusDoneThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            focusDoneThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableFineScanExtension") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFineScanExtension = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "firstRunNotConfidenceAdd") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            firstRunNotConfidenceAdd = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDFocusScanType::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);

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

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

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

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

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

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

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

    return __result;
}

bool chromatixPDDofScalerEntryType::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, "normalizedLensPosition") == 0)
    {
        ParameterUtils::DoubleToString((double)normalizedLensPosition, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dofScaler") == 0)
    {
        ParameterUtils::DoubleToString((double)dofScaler, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDDofScalerEntryType::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, "normalizedLensPosition") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            normalizedLensPosition = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dofScaler") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dofScaler = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDDofScalerEntryType::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);

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

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

    return __result;
}

bool chromatixPDDofScalerTableType::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, "dofScalerEntries") == 0)
    {
        if (__index < dofScalerEntriesCount)
        {
            __result = dofScalerEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDDofScalerTableType::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, "dofScalerEntries") == 0)
    {
        if (__index < dofScalerEntriesCount)
        {
            __result = dofScalerEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDDofScalerTableType::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);

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

    return __result;
}

bool chromatixPDStableTableEntryType::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, "FPS") == 0)
    {
        ParameterUtils::DoubleToString((double)FPS, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minimumStableCount") == 0)
    {
        ParameterUtils::DoubleToString((double)minimumStableCount, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDStableTableEntryType::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, "FPS") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FPS = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minimumStableCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minimumStableCount = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDStableTableEntryType::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);

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

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

    return __result;
}

bool chromatixPDStableTableType::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, "stableEntries") == 0)
    {
        if (__index < stableEntriesCount)
        {
            __result = stableEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDStableTableType::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, "stableEntries") == 0)
    {
        if (__index < stableEntriesCount)
        {
            __result = stableEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDStableTableType::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);

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

    return __result;
}

bool confidenceSensitivityModifierArr::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, "sceneBasedSensitivityModifier") == 0)
    {
        if (__index < sceneBasedSensitivityModifierCount)
        {
            __result = sceneBasedSensitivityModifier[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiTypeBasedSensitivityModifier") == 0)
    {
        if (__index < roiTypeBasedSensitivityModifierCount)
        {
            __result = roiTypeBasedSensitivityModifier[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiSizeBasedSensitivityModifier") == 0)
    {
        if (__index < roiSizeBasedSensitivityModifierCount)
        {
            __result = roiSizeBasedSensitivityModifier[__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, "windowBasedSensitivityModifier") == 0)
    {
        if (__index < windowBasedSensitivityModifierCount)
        {
            __result = windowBasedSensitivityModifier[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "expIndexBasedSensitivityModifier") == 0)
    {
        if (__index < expIndexBasedSensitivityModifierCount)
        {
            __result = expIndexBasedSensitivityModifier[__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 confidenceSensitivityModifierArr::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, "sceneBasedSensitivityModifier") == 0)
    {
        if (__index < sceneBasedSensitivityModifierCount)
        {
            __result = sceneBasedSensitivityModifier[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiTypeBasedSensitivityModifier") == 0)
    {
        if (__index < roiTypeBasedSensitivityModifierCount)
        {
            __result = roiTypeBasedSensitivityModifier[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiSizeBasedSensitivityModifier") == 0)
    {
        if (__index < roiSizeBasedSensitivityModifierCount)
        {
            __result = roiSizeBasedSensitivityModifier[__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, "windowBasedSensitivityModifier") == 0)
    {
        if (__index < windowBasedSensitivityModifierCount)
        {
            __result = windowBasedSensitivityModifier[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "expIndexBasedSensitivityModifier") == 0)
    {
        if (__index < expIndexBasedSensitivityModifierCount)
        {
            __result = expIndexBasedSensitivityModifier[__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 confidenceSensitivityModifierArr::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);

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

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

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

    // 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));
        }
    }

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

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

    // 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 PDConfidenceThresholdsType::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, "low") == 0)
    {
        ParameterUtils::DoubleToString((double)low, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "mid") == 0)
    {
        ParameterUtils::DoubleToString((double)mid, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "high") == 0)
    {
        ParameterUtils::DoubleToString((double)high, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool PDConfidenceThresholdsType::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, "low") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            low = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "mid") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            mid = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "high") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            high = (INT32)dblValue; 
        }
    }

    return __result;
}

bool PDConfidenceThresholdsType::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);

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

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

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

    return __result;
}

bool sensitivityBasedConfidenceTableType::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, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "normalConfidence") == 0)
    {
        __result = normalConfidence.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "highConfidence") == 0)
    {
        __result = highConfidence.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityModifiers") == 0)
    {
        __result = sensitivityModifiers.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool sensitivityBasedConfidenceTableType::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, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "normalConfidence") == 0)
    {
        __result = normalConfidence.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "highConfidence") == 0)
    {
        __result = highConfidence.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityModifiers") == 0)
    {
        __result = sensitivityModifiers.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool sensitivityBasedConfidenceTableType::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);

    // 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));
    }

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

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

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

    return __result;
}

bool chromatixPDConfidenceTableEntryType::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, "noiseGain") == 0)
    {
        ParameterUtils::DoubleToString((double)noiseGain, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minimumConfidence") == 0)
    {
        ParameterUtils::DoubleToString((double)minimumConfidence, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDConfidenceTableEntryType::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, "noiseGain") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            noiseGain = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minimumConfidence") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minimumConfidence = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDConfidenceTableEntryType::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);

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

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

    return __result;
}

bool chromatixPDConfidenceTableType::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, "confidenceEntries") == 0)
    {
        if (__index < confidenceEntriesCount)
        {
            __result = confidenceEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDConfidenceTableType::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, "confidenceEntries") == 0)
    {
        if (__index < confidenceEntriesCount)
        {
            __result = confidenceEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDConfidenceTableType::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);

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

    return __result;
}

bool chromatixPDNoiseTableEntryType::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, "noiseGain") == 0)
    {
        ParameterUtils::DoubleToString((double)noiseGain, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "noiseGainMultiplier") == 0)
    {
        ParameterUtils::DoubleToString((double)noiseGainMultiplier, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixPDNoiseTableEntryType::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, "noiseGain") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            noiseGain = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "noiseGainMultiplier") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            noiseGainMultiplier = (float)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDNoiseTableEntryType::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);

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

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

    return __result;
}

bool chromatixPDNoiseTableType::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, "noiseEntries") == 0)
    {
        if (__index < noiseEntriesCount)
        {
            __result = noiseEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDNoiseTableType::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, "noiseEntries") == 0)
    {
        if (__index < noiseEntriesCount)
        {
            __result = noiseEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDNoiseTableType::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);

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

    return __result;
}

bool chromatixPDROIConfigType::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, "ROILocationY") == 0)
    {
        ParameterUtils::DoubleToString((double)ROILocationY, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ROILocationX") == 0)
    {
        ParameterUtils::DoubleToString((double)ROILocationX, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ROINumRows") == 0)
    {
        ParameterUtils::DoubleToString((double)ROINumRows, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ROINumCols") == 0)
    {
        ParameterUtils::DoubleToString((double)ROINumCols, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDROIConfigType::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, "ROILocationY") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROILocationY = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROILocationX") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROILocationX = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROINumRows") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROINumRows = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROINumCols") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROINumCols = (INT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDROIConfigType::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);

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

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

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

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

    return __result;
}

bool chromatixPDROIType::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, "Configuration") == 0)
    {
        if (__index < ConfigurationCount)
        {
            __result = Configuration[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDROIType::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, "Configuration") == 0)
    {
        if (__index < ConfigurationCount)
        {
            __result = Configuration[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDROIType::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);

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

    return __result;
}

bool chromatixPDAFType::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, "is2PDEnable") == 0)
    {
        ParameterUtils::DoubleToString((double)is2PDEnable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ROI") == 0)
    {
        __result = ROI.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "focusTable") == 0)
    {
        __result = focusTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "noiseTable") == 0)
    {
        __result = noiseTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "confidenceTable") == 0)
    {
        __result = confidenceTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "confidenceHighTable") == 0)
    {
        __result = confidenceHighTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityBasedConfidenceTable") == 0)
    {
        __result = sensitivityBasedConfidenceTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "fallbackConfidence") == 0)
    {
        ParameterUtils::DoubleToString((double)fallbackConfidence, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stableTable") == 0)
    {
        __result = stableTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "dofScalerTable") == 0)
    {
        __result = dofScalerTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "focusScan") == 0)
    {
        __result = focusScan.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sceneMonitor") == 0)
    {
        __result = sceneMonitor.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "PDPreprocessing") == 0)
    {
        __result = PDPreprocessing.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "PDInternal") == 0)
    {
        __result = PDInternal.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "PDMultiWindow") == 0)
    {
        __result = PDMultiWindow.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "AdaptivePDOffsetCorrection") == 0)
    {
        __result = AdaptivePDOffsetCorrection.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enablePDEarlyInterrupt") == 0)
    {
        ParameterUtils::DoubleToString((double)enablePDEarlyInterrupt, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dynamicFrameSkipVBlankThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)dynamicFrameSkipVBlankThreshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ledPdafMaxFrameAllow") == 0)
    {
        __result = ledPdafMaxFrameAllow.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sparsePDTouchFaceConfidenceThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)sparsePDTouchFaceConfidenceThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "sparsePDTouchFaceLowDefocusConfidenceThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)sparsePDTouchFaceLowDefocusConfidenceThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableEnterLSPLowConfidenceHunting") == 0)
    {
        ParameterUtils::DoubleToString((double)enableEnterLSPLowConfidenceHunting, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "LSPLowConfidenceHuntingThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)LSPLowConfidenceHuntingThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "face") == 0)
    {
        __result = face.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "touch") == 0)
    {
        __result = touch.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "track") == 0)
    {
        __result = track.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "saliency") == 0)
    {
        __result = saliency.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "convergeDoneFilter") == 0)
    {
        __result = convergeDoneFilter.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "forceEnterFineSearch") == 0)
    {
        __result = forceEnterFineSearch.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "advancedSparseControl") == 0)
    {
        __result = advancedSparseControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "mlpdControl") == 0)
    {
        __result = mlpdControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "motionConvergeControl") == 0)
    {
        __result = motionConvergeControl.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "temporalFilter") == 0)
    {
        __result = temporalFilter.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "multiROISelection") == 0)
    {
        __result = multiROISelection.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDAFType::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, "is2PDEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            is2PDEnable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROI") == 0)
    {
        __result = ROI.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "focusTable") == 0)
    {
        __result = focusTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "noiseTable") == 0)
    {
        __result = noiseTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "confidenceTable") == 0)
    {
        __result = confidenceTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "confidenceHighTable") == 0)
    {
        __result = confidenceHighTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sensitivityBasedConfidenceTable") == 0)
    {
        __result = sensitivityBasedConfidenceTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "fallbackConfidence") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fallbackConfidence = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stableTable") == 0)
    {
        __result = stableTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "dofScalerTable") == 0)
    {
        __result = dofScalerTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "focusScan") == 0)
    {
        __result = focusScan.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sceneMonitor") == 0)
    {
        __result = sceneMonitor.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "PDPreprocessing") == 0)
    {
        __result = PDPreprocessing.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "PDInternal") == 0)
    {
        __result = PDInternal.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "PDMultiWindow") == 0)
    {
        __result = PDMultiWindow.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "AdaptivePDOffsetCorrection") == 0)
    {
        __result = AdaptivePDOffsetCorrection.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enablePDEarlyInterrupt") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enablePDEarlyInterrupt = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dynamicFrameSkipVBlankThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dynamicFrameSkipVBlankThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ledPdafMaxFrameAllow") == 0)
    {
        __result = ledPdafMaxFrameAllow.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sparsePDTouchFaceConfidenceThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sparsePDTouchFaceConfidenceThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sparsePDTouchFaceLowDefocusConfidenceThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sparsePDTouchFaceLowDefocusConfidenceThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableEnterLSPLowConfidenceHunting") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableEnterLSPLowConfidenceHunting = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LSPLowConfidenceHuntingThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            LSPLowConfidenceHuntingThreshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "face") == 0)
    {
        __result = face.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "touch") == 0)
    {
        __result = touch.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "track") == 0)
    {
        __result = track.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "saliency") == 0)
    {
        __result = saliency.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "convergeDoneFilter") == 0)
    {
        __result = convergeDoneFilter.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "forceEnterFineSearch") == 0)
    {
        __result = forceEnterFineSearch.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "advancedSparseControl") == 0)
    {
        __result = advancedSparseControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "mlpdControl") == 0)
    {
        __result = mlpdControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "motionConvergeControl") == 0)
    {
        __result = motionConvergeControl.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "temporalFilter") == 0)
    {
        __result = temporalFilter.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "multiROISelection") == 0)
    {
        __result = multiROISelection.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDAFType::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);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatixPDAFType::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 chromatixPDAFType::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 chromatixPDAFType::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 chromatixPDAFType::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 chromatixPDAFType::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 chromatixPDAFType::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;
}

bool chromatixPDAFType::ledPdafMaxFrameAllowStruct::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, "maxFrameCnt") == 0)
    {
        ParameterUtils::DoubleToString((double)maxFrameCnt, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixPDAFType::ledPdafMaxFrameAllowStruct::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 = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxFrameCnt") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxFrameCnt = (UINT32)dblValue; 
        }
    }

    return __result;
}

bool chromatixPDAFType::ledPdafMaxFrameAllowStruct::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));
    }

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

    return __result;
}

bool chromatixPDAFType::motionConvergeControlStruct::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, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "motionConvergeTable") == 0)
    {
        __result = motionConvergeTable.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDAFType::motionConvergeControlStruct::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, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "motionConvergeTable") == 0)
    {
        __result = motionConvergeTable.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDAFType::motionConvergeControlStruct::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);

    // 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));
    }

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

    return __result;
}

bool chromatixPDAFType::temporalFilterStruct::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, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "search") == 0)
    {
        __result = search.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "monitor") == 0)
    {
        __result = monitor.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixPDAFType::temporalFilterStruct::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, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "search") == 0)
    {
        __result = search.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "monitor") == 0)
    {
        __result = monitor.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool chromatixPDAFType::temporalFilterStruct::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);

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

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

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

    return __result;
}

bool chromatixPDAFType::multiROISelectionStruct::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, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "configArr") == 0)
    {
        if (__index < configArrCount)
        {
            __result = configArr[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatixPDAFType::multiROISelectionStruct::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, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "configArr") == 0)
    {
        if (__index < configArrCount)
        {
            __result = configArr[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

bool chromatixPDAFType::multiROISelectionStruct::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);

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

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

    return __result;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixPDAFTypeClass::chromatixPDAFTypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(is2PDEnable);
    PARAMETER_INITIALIZE(ROI);
    PARAMETER_INITIALIZE(focusTable);
    PARAMETER_INITIALIZE(noiseTable);
    PARAMETER_INITIALIZE(confidenceTable);
    PARAMETER_INITIALIZE(confidenceHighTable);
    PARAMETER_INITIALIZE(sensitivityBasedConfidenceTable);
    PARAMETER_INITIALIZE(fallbackConfidence);
    PARAMETER_INITIALIZE(stableTable);
    PARAMETER_INITIALIZE(dofScalerTable);
    PARAMETER_INITIALIZE(focusScan);
    PARAMETER_INITIALIZE(sceneMonitor);
    PARAMETER_INITIALIZE(PDPreprocessing);
    PARAMETER_INITIALIZE(PDInternal);
    PARAMETER_INITIALIZE(PDMultiWindow);
    PARAMETER_INITIALIZE(AdaptivePDOffsetCorrection);
    PARAMETER_INITIALIZE(enablePDEarlyInterrupt);
    PARAMETER_INITIALIZE(dynamicFrameSkipVBlankThreshold);
    PARAMETER_INITIALIZE(ledPdafMaxFrameAllow);
    PARAMETER_INITIALIZE(sparsePDTouchFaceConfidenceThreshold);
    PARAMETER_INITIALIZE(sparsePDTouchFaceLowDefocusConfidenceThreshold);
    PARAMETER_INITIALIZE(enableEnterLSPLowConfidenceHunting);
    PARAMETER_INITIALIZE(LSPLowConfidenceHuntingThreshold);
    PARAMETER_INITIALIZE(face);
    PARAMETER_INITIALIZE(touch);
    PARAMETER_INITIALIZE(track);
    PARAMETER_INITIALIZE(saliency);
    PARAMETER_INITIALIZE(convergeDoneFilter);
    PARAMETER_INITIALIZE(forceEnterFineSearch);
    PARAMETER_INITIALIZE(advancedSparseControl);
    PARAMETER_INITIALIZE(mlpdControl);
    PARAMETER_INITIALIZE(motionConvergeControl);
    PARAMETER_INITIALIZE(temporalFilter);
    PARAMETER_INITIALIZE(multiROISelection);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixPDAFTypeClass::chromatixPDAFTypeClass(
    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(is2PDEnable);
    PARAMETER_INITIALIZE(ROI);
    PARAMETER_INITIALIZE(focusTable);
    PARAMETER_INITIALIZE(noiseTable);
    PARAMETER_INITIALIZE(confidenceTable);
    PARAMETER_INITIALIZE(confidenceHighTable);
    PARAMETER_INITIALIZE(sensitivityBasedConfidenceTable);
    PARAMETER_INITIALIZE(fallbackConfidence);
    PARAMETER_INITIALIZE(stableTable);
    PARAMETER_INITIALIZE(dofScalerTable);
    PARAMETER_INITIALIZE(focusScan);
    PARAMETER_INITIALIZE(sceneMonitor);
    PARAMETER_INITIALIZE(PDPreprocessing);
    PARAMETER_INITIALIZE(PDInternal);
    PARAMETER_INITIALIZE(PDMultiWindow);
    PARAMETER_INITIALIZE(AdaptivePDOffsetCorrection);
    PARAMETER_INITIALIZE(enablePDEarlyInterrupt);
    PARAMETER_INITIALIZE(dynamicFrameSkipVBlankThreshold);
    PARAMETER_INITIALIZE(ledPdafMaxFrameAllow);
    PARAMETER_INITIALIZE(sparsePDTouchFaceConfidenceThreshold);
    PARAMETER_INITIALIZE(sparsePDTouchFaceLowDefocusConfidenceThreshold);
    PARAMETER_INITIALIZE(enableEnterLSPLowConfidenceHunting);
    PARAMETER_INITIALIZE(LSPLowConfidenceHuntingThreshold);
    PARAMETER_INITIALIZE(face);
    PARAMETER_INITIALIZE(touch);
    PARAMETER_INITIALIZE(track);
    PARAMETER_INITIALIZE(saliency);
    PARAMETER_INITIALIZE(convergeDoneFilter);
    PARAMETER_INITIALIZE(forceEnterFineSearch);
    PARAMETER_INITIALIZE(advancedSparseControl);
    PARAMETER_INITIALIZE(mlpdControl);
    PARAMETER_INITIALIZE(motionConvergeControl);
    PARAMETER_INITIALIZE(temporalFilter);
    PARAMETER_INITIALIZE(multiROISelection);
}

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

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

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

    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(lowConfidenceMultiplier);
    PARAMETER_INITIALIZE(highConfidenceMultiplier);

    result = afglobalelements::ReadEnum_AFTriggerCtrlTypeROIEnum(entry, type, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, lowConfidenceMultiplier, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, highConfidenceMultiplier, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(gainThreshold);
    PARAMETER_INITIALIZE(confidenceWeightLUT);
    PARAMETER_INITIALIZE(lensMoveWeightLUT);
    PARAMETER_INITIALIZE(frameDelayWeight);

    SYMBOL_TABLE_ENTRY_READ(entry, result, gainThreshold, alignment)
    if (result)
    {
        result = confidenceWeightLUT.Load(entry, alignment);
    }
    if (result)
    {
        result = lensMoveWeightLUT.Load(entry, alignment);
    }
    if (result)
    {
        result = frameDelayWeight.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(weights);


    // Reading Array weights from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        weightsCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, weightsCount, 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)
        {
            weightsID = pointerEntry->ID;
            DupObjInfo* weightsDupInfo = pointerEntry->GetDupObject(weightsCount, file, line);
            if (weightsDupInfo != nullptr && weightsDupInfo->Object != nullptr)
            {
                weights = (float*)weightsDupInfo->Object;
                if (weights == nullptr)
                {
                    if (weightsDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "weights duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            weightsDupInfo->File, weightsDupInfo->Line, weightsDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "weights duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            weightsDupInfo->Line, weightsDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(setting);


    // Reading Array setting from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        settingCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, settingCount, 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)
        {
            settingID = pointerEntry->ID;
            DupObjInfo* settingDupInfo = pointerEntry->GetDupObject(settingCount, file, line);
            if (settingDupInfo != nullptr && settingDupInfo->Object != nullptr)
            {
                setting = (chromatixPDAFTemporalFilterSettingType*)settingDupInfo->Object;
                if (setting == nullptr)
                {
                    if (settingDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "setting duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            settingDupInfo->File, settingDupInfo->Line, settingDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "setting duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            settingDupInfo->Line, settingDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(motion);
    PARAMETER_INITIALIZE(scaler);

    SYMBOL_TABLE_ENTRY_READ(entry, result, motion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, scaler, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(motionConvergeEntries);


    // Reading Array motionConvergeEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        motionConvergeEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, motionConvergeEntriesCount, 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)
        {
            motionConvergeEntriesID = pointerEntry->ID;
            DupObjInfo* motionConvergeEntriesDupInfo = pointerEntry->GetDupObject(motionConvergeEntriesCount, file, line);
            if (motionConvergeEntriesDupInfo != nullptr && motionConvergeEntriesDupInfo->Object != nullptr)
            {
                motionConvergeEntries = (chromatixPDMotionConvergeScalerEntryType*)motionConvergeEntriesDupInfo->Object;
                if (motionConvergeEntries == nullptr)
                {
                    if (motionConvergeEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "motionConvergeEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            motionConvergeEntriesDupInfo->File, motionConvergeEntriesDupInfo->Line, motionConvergeEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "motionConvergeEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            motionConvergeEntriesDupInfo->Line, motionConvergeEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(enableMLPD);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableMLPD, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(defocus);
    PARAMETER_INITIALIZE(movePercent);

    SYMBOL_TABLE_ENTRY_READ(entry, result, defocus, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, movePercent, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(focusEntries);


    // Reading Array focusEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        focusEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, focusEntriesCount, 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)
        {
            focusEntriesID = pointerEntry->ID;
            DupObjInfo* focusEntriesDupInfo = pointerEntry->GetDupObject(focusEntriesCount, file, line);
            if (focusEntriesDupInfo != nullptr && focusEntriesDupInfo->Object != nullptr)
            {
                focusEntries = (chromatixPDFocusTableEntryType*)focusEntriesDupInfo->Object;
                if (focusEntries == nullptr)
                {
                    if (focusEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "focusEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            focusEntriesDupInfo->File, focusEntriesDupInfo->Line, focusEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "focusEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            focusEntriesDupInfo->Line, focusEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(enableForSparsePD);
    PARAMETER_INITIALIZE(skipFineScan);
    PARAMETER_INITIALIZE(focusDoneThreshold);
    PARAMETER_INITIALIZE(focusTable);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableForSparsePD, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, skipFineScan, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, focusDoneThreshold, alignment)
    if (result)
    {
        result = focusTable.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(directionReverseCountThreshold);

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(length);
    PARAMETER_INITIALIZE(threshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, length, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, threshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(saliencyROIProcess);
    PARAMETER_INITIALIZE(minMoveThreshold);
    PARAMETER_INITIALIZE(defocusFilter);
    PARAMETER_INITIALIZE(fallback);

    result = saliencyROIProcess.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, minMoveThreshold, alignment)
    if (result)
    {
        result = defocusFilter.Load(entry, alignment);
    }
    if (result)
    {
        result = fallback.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(saliencyROIRoughStable);
    PARAMETER_INITIALIZE(saliencyROIStrictStable);

    result = saliencyROIRoughStable.Load(entry, alignment);
    if (result)
    {
        result = saliencyROIStrictStable.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(length);
    PARAMETER_INITIALIZE(confidenceHighThreshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, length, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confidenceHighThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(fallbackROISizeThreshold);

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

    return result;
}

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

    PARAMETER_INITIALIZE(trackROIProcess);
    PARAMETER_INITIALIZE(minMoveThreshold);
    PARAMETER_INITIALIZE(defocusFilter);
    PARAMETER_INITIALIZE(fallback);

    result = trackROIProcess.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, minMoveThreshold, alignment)
    if (result)
    {
        result = defocusFilter.Load(entry, alignment);
    }
    if (result)
    {
        result = fallback.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(trackROIRoughStable);
    PARAMETER_INITIALIZE(trackROIStrictStable);

    result = trackROIRoughStable.Load(entry, alignment);
    if (result)
    {
        result = trackROIStrictStable.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(length);
    PARAMETER_INITIALIZE(confidenceHighThreshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, length, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confidenceHighThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(fallbackROISizeThreshold);

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

    return result;
}

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

    PARAMETER_INITIALIZE(offCenterThreshold);
    PARAMETER_INITIALIZE(skipSearchIfSceneInFocus);

    SYMBOL_TABLE_ENTRY_READ(entry, result, offCenterThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, skipSearchIfSceneInFocus, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(faceROIProcess);
    PARAMETER_INITIALIZE(minMoveThreshold);
    PARAMETER_INITIALIZE(ROIMoveConvergeSuppress);
    PARAMETER_INITIALIZE(defocusFilter);
    PARAMETER_INITIALIZE(fallback);
    PARAMETER_INITIALIZE(faceChangeRefocusTrigger);

    result = faceROIProcess.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, minMoveThreshold, alignment)
    if (result)
    {
        result = ROIMoveConvergeSuppress.Load(entry, alignment);
    }
    if (result)
    {
        result = defocusFilter.Load(entry, alignment);
    }
    if (result)
    {
        result = fallback.Load(entry, alignment);
    }
    if (result)
    {
        result = faceChangeRefocusTrigger.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(ROIProcessEnable);
    PARAMETER_INITIALIZE(ROIRoughStable);
    PARAMETER_INITIALIZE(ROIStrictStable);

    SYMBOL_TABLE_ENTRY_READ(entry, result, ROIProcessEnable, alignment)
    if (result)
    {
        result = ROIRoughStable.Load(entry, alignment);
    }
    if (result)
    {
        result = ROIStrictStable.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(stableCountThreshold);
    PARAMETER_INITIALIZE(moveThresholdInX);
    PARAMETER_INITIALIZE(moveThresholdInY);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, stableCountThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, moveThresholdInX, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, moveThresholdInY, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(length);
    PARAMETER_INITIALIZE(confidenceHighThreshold);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, length, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confidenceHighThreshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(fallbackROISizeThreshold);

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(roiChangeThreshPercentage);
    PARAMETER_INITIALIZE(roiSizeStableThresh);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, roiChangeThreshPercentage, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, roiSizeStableThresh, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(lpInterval);

    SYMBOL_TABLE_ENTRY_READ(entry, result, lpInterval, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(lensPosIntervalListEntries);


    // Reading Array lensPosIntervalListEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        lensPosIntervalListEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, lensPosIntervalListEntriesCount, 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)
        {
            lensPosIntervalListEntriesID = pointerEntry->ID;
            DupObjInfo* lensPosIntervalListEntriesDupInfo = pointerEntry->GetDupObject(lensPosIntervalListEntriesCount, file, line);
            if (lensPosIntervalListEntriesDupInfo != nullptr && lensPosIntervalListEntriesDupInfo->Object != nullptr)
            {
                lensPosIntervalListEntries = (chromatixlensPosIntervalListEntriesType*)lensPosIntervalListEntriesDupInfo->Object;
                if (lensPosIntervalListEntries == nullptr)
                {
                    if (lensPosIntervalListEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "lensPosIntervalListEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            lensPosIntervalListEntriesDupInfo->File, lensPosIntervalListEntriesDupInfo->Line, lensPosIntervalListEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "lensPosIntervalListEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            lensPosIntervalListEntriesDupInfo->Line, lensPosIntervalListEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(luxIndex);

    SYMBOL_TABLE_ENTRY_READ(entry, result, luxIndex, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(luxNodeListEntries);


    // Reading Array luxNodeListEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        luxNodeListEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, luxNodeListEntriesCount, 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)
        {
            luxNodeListEntriesID = pointerEntry->ID;
            DupObjInfo* luxNodeListEntriesDupInfo = pointerEntry->GetDupObject(luxNodeListEntriesCount, file, line);
            if (luxNodeListEntriesDupInfo != nullptr && luxNodeListEntriesDupInfo->Object != nullptr)
            {
                luxNodeListEntries = (chromatixluxNodeListEntriesType*)luxNodeListEntriesDupInfo->Object;
                if (luxNodeListEntries == nullptr)
                {
                    if (luxNodeListEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "luxNodeListEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            luxNodeListEntriesDupInfo->File, luxNodeListEntriesDupInfo->Line, luxNodeListEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "luxNodeListEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            luxNodeListEntriesDupInfo->Line, luxNodeListEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(minSampleRequired);
    PARAMETER_INITIALIZE(maxSampleCount);
    PARAMETER_INITIALIZE(enableOutlierRemoval);
    PARAMETER_INITIALIZE(outlierRemovalRatio);
    PARAMETER_INITIALIZE(pdSampleConfThresholdMin);
    PARAMETER_INITIALIZE(interpolateDistance);
    PARAMETER_INITIALIZE(recollectSampleTimeThres);
    PARAMETER_INITIALIZE(maxFinesearchFrameCount);
    PARAMETER_INITIALIZE(enableFastStartMode);
    PARAMETER_INITIALIZE(defocusOffsetMin);
    PARAMETER_INITIALIZE(defocusOffsetMax);
    PARAMETER_INITIALIZE(frameDelayCount);
    PARAMETER_INITIALIZE(maxSlope);
    PARAMETER_INITIALIZE(minDistributionScore);
    PARAMETER_INITIALIZE(numTemperatureNode);
    PARAMETER_INITIALIZE(minTemp);
    PARAMETER_INITIALIZE(maxTemp);
    PARAMETER_INITIALIZE(diffusionRatio1);
    PARAMETER_INITIALIZE(diffusionRatio2);
    PARAMETER_INITIALIZE(mapWidth);
    PARAMETER_INITIALIZE(mapHeight);
    PARAMETER_INITIALIZE(minGridMapOverlapRatio1);
    PARAMETER_INITIALIZE(minGridMapOverlapRatio2);
    PARAMETER_INITIALIZE(scGyroThres);
    PARAMETER_INITIALIZE(scMVThres);
    PARAMETER_INITIALIZE(luxNodeList);
    PARAMETER_INITIALIZE(lensPosIntervalList);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minSampleRequired, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxSampleCount, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableOutlierRemoval, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, outlierRemovalRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pdSampleConfThresholdMin, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, interpolateDistance, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, recollectSampleTimeThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxFinesearchFrameCount, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFastStartMode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusOffsetMin, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusOffsetMax, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frameDelayCount, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxSlope, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minDistributionScore, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numTemperatureNode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minTemp, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxTemp, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diffusionRatio1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diffusionRatio2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, mapWidth, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, mapHeight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minGridMapOverlapRatio1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minGridMapOverlapRatio2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, scGyroThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, scMVThres, alignment)
    if (result)
    {
        result = luxNodeList.Load(entry, alignment);
    }
    if (result)
    {
        result = lensPosIntervalList.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(HNumWindows);
    PARAMETER_INITIALIZE(VNumWindows);
    PARAMETER_INITIALIZE(PDPercentile);
    PARAMETER_INITIALIZE(defocusThreshold);
    PARAMETER_INITIALIZE(confidenceThMultiple);
    PARAMETER_INITIALIZE(multiDepthDetect);
    PARAMETER_INITIALIZE(lowLightDetect);
    PARAMETER_INITIALIZE(lockToPeripheralDuringSearch);
    PARAMETER_INITIALIZE(activZoomControl);
    PARAMETER_INITIALIZE(saliencyMWTuning);
    PARAMETER_INITIALIZE(motionMWTuning);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, HNumWindows, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, VNumWindows, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, PDPercentile, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confidenceThMultiple, alignment)
    if (result)
    {
        result = multiDepthDetect.Load(entry, alignment);
    }
    if (result)
    {
        result = lowLightDetect.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, lockToPeripheralDuringSearch, alignment)
    if (result)
    {
        result = activZoomControl.Load(entry, alignment);
    }
    if (result)
    {
        result = saliencyMWTuning.Load(entry, alignment);
    }
    if (result)
    {
        result = motionMWTuning.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(percentile);
    PARAMETER_INITIALIZE(detectThLow);
    PARAMETER_INITIALIZE(detectThHigh);

    SYMBOL_TABLE_ENTRY_READ(entry, result, percentile, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, detectThLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, detectThHigh, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(gainThLow);
    PARAMETER_INITIALIZE(gainThHigh);

    SYMBOL_TABLE_ENTRY_READ(entry, result, gainThLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gainThHigh, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(zoomThreshold);

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(saliencyTh);
    PARAMETER_INITIALIZE(saliencyStdTh);
    PARAMETER_INITIALIZE(saliencyPriorityWeight);
    PARAMETER_INITIALIZE(saliencyLUT);
    PARAMETER_INITIALIZE(phaseDiffLUT);
    PARAMETER_INITIALIZE(confidenceLUT);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, saliencyTh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, saliencyStdTh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, saliencyPriorityWeight, alignment)
    if (result)
    {
        result = saliencyLUT.Load(entry, alignment);
    }
    if (result)
    {
        result = phaseDiffLUT.Load(entry, alignment);
    }
    if (result)
    {
        result = confidenceLUT.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(motionTh);

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

    return result;
}

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

    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(initialPosition);
    PARAMETER_INITIALIZE(PDAFEnableFaceCAFPriority);
    PARAMETER_INITIALIZE(incDefocusThresholdPreviousError);
    PARAMETER_INITIALIZE(fineScanRangeEnhance);
    PARAMETER_INITIALIZE(softRegionThresholdMultiplier);
    PARAMETER_INITIALIZE(enableSoftConfidenceThreshold);
    PARAMETER_INITIALIZE(softConfidenceThresholdDelta);
    PARAMETER_INITIALIZE(softConfidenceFocus_pnt);
    PARAMETER_INITIALIZE(enableSoftRegionThresholdHigh);
    PARAMETER_INITIALIZE(softRegionThresholdHighMultiplier);
    PARAMETER_INITIALIZE(softSceneChangeCount);
    PARAMETER_INITIALIZE(cafStableFrameAllow);

    SYMBOL_TABLE_ENTRY_READ(entry, result, type, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, initialPosition, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, PDAFEnableFaceCAFPriority, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, incDefocusThresholdPreviousError, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fineScanRangeEnhance, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, softRegionThresholdMultiplier, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableSoftConfidenceThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, softConfidenceThresholdDelta, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, softConfidenceFocus_pnt, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableSoftRegionThresholdHigh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, softRegionThresholdHighMultiplier, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, softSceneChangeCount, alignment)
    if (result)
    {
        result = cafStableFrameAllow.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(frameCount);

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(enableDoNotUseDefocusSampleByPD);
    PARAMETER_INITIALIZE(enableIncMinConfidenceThresholdByPD);
    PARAMETER_INITIALIZE(PDMaxLimitDoNotUseDefocusSample);
    PARAMETER_INITIALIZE(PDMaxLimitIncMinConfidenceThreshold);
    PARAMETER_INITIALIZE(incMinConfidenceThresholdByPDScaler);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableDoNotUseDefocusSampleByPD, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableIncMinConfidenceThresholdByPD, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, PDMaxLimitDoNotUseDefocusSample, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, PDMaxLimitIncMinConfidenceThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, incMinConfidenceThresholdByPDScaler, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(waitConfidenceRecoverCount);
    PARAMETER_INITIALIZE(defocusedThreshold);
    PARAMETER_INITIALIZE(depthStableThreshold);
    PARAMETER_INITIALIZE(defocusStableFilterLength);

    SYMBOL_TABLE_ENTRY_READ(entry, result, waitConfidenceRecoverCount, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusedThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, depthStableThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, defocusStableFilterLength, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(focusConvergeFrameSkip);
    PARAMETER_INITIALIZE(enableFineScan);
    PARAMETER_INITIALIZE(minimumFineScanRange);
    PARAMETER_INITIALIZE(fineScanStepSize);
    PARAMETER_INITIALIZE(focusDoneThreshold);
    PARAMETER_INITIALIZE(enableFineScanExtension);
    PARAMETER_INITIALIZE(firstRunNotConfidenceAdd);

    SYMBOL_TABLE_ENTRY_READ(entry, result, focusConvergeFrameSkip, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFineScan, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minimumFineScanRange, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fineScanStepSize, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, focusDoneThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFineScanExtension, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, firstRunNotConfidenceAdd, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(normalizedLensPosition);
    PARAMETER_INITIALIZE(dofScaler);

    SYMBOL_TABLE_ENTRY_READ(entry, result, normalizedLensPosition, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, dofScaler, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(dofScalerEntries);


    // Reading Array dofScalerEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        dofScalerEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, dofScalerEntriesCount, 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)
        {
            dofScalerEntriesID = pointerEntry->ID;
            DupObjInfo* dofScalerEntriesDupInfo = pointerEntry->GetDupObject(dofScalerEntriesCount, file, line);
            if (dofScalerEntriesDupInfo != nullptr && dofScalerEntriesDupInfo->Object != nullptr)
            {
                dofScalerEntries = (chromatixPDDofScalerEntryType*)dofScalerEntriesDupInfo->Object;
                if (dofScalerEntries == nullptr)
                {
                    if (dofScalerEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "dofScalerEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            dofScalerEntriesDupInfo->File, dofScalerEntriesDupInfo->Line, dofScalerEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "dofScalerEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            dofScalerEntriesDupInfo->Line, dofScalerEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(FPS);
    PARAMETER_INITIALIZE(minimumStableCount);

    SYMBOL_TABLE_ENTRY_READ(entry, result, FPS, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minimumStableCount, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(stableEntries);


    // Reading Array stableEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        stableEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, stableEntriesCount, 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)
        {
            stableEntriesID = pointerEntry->ID;
            DupObjInfo* stableEntriesDupInfo = pointerEntry->GetDupObject(stableEntriesCount, file, line);
            if (stableEntriesDupInfo != nullptr && stableEntriesDupInfo->Object != nullptr)
            {
                stableEntries = (chromatixPDStableTableEntryType*)stableEntriesDupInfo->Object;
                if (stableEntries == nullptr)
                {
                    if (stableEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "stableEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            stableEntriesDupInfo->File, stableEntriesDupInfo->Line, stableEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "stableEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            stableEntriesDupInfo->Line, stableEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(sceneBasedSensitivityModifier);
    PARAMETER_INITIALIZE(roiTypeBasedSensitivityModifier);
    PARAMETER_INITIALIZE(roiSizeBasedSensitivityModifier);
    PARAMETER_INITIALIZE(zoomBasedSensitivityModifier);
    PARAMETER_INITIALIZE(windowBasedSensitivityModifier);
    PARAMETER_INITIALIZE(expIndexBasedSensitivityModifier);
    PARAMETER_INITIALIZE(gainBasedSensitivityModifier);


    // Reading Array sceneBasedSensitivityModifier from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        sceneBasedSensitivityModifierCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, sceneBasedSensitivityModifierCount, 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)
        {
            sceneBasedSensitivityModifierID = pointerEntry->ID;
            DupObjInfo* sceneBasedSensitivityModifierDupInfo = pointerEntry->GetDupObject(sceneBasedSensitivityModifierCount, file, line);
            if (sceneBasedSensitivityModifierDupInfo != nullptr && sceneBasedSensitivityModifierDupInfo->Object != nullptr)
            {
                sceneBasedSensitivityModifier = (afglobalelements::SceneTypeSensitivityModifier*)sceneBasedSensitivityModifierDupInfo->Object;
                if (sceneBasedSensitivityModifier == nullptr)
                {
                    if (sceneBasedSensitivityModifierDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sceneBasedSensitivityModifier duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            sceneBasedSensitivityModifierDupInfo->File, sceneBasedSensitivityModifierDupInfo->Line, sceneBasedSensitivityModifierDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "sceneBasedSensitivityModifier duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            sceneBasedSensitivityModifierDupInfo->Line, sceneBasedSensitivityModifierDupInfo->RefCount);
                    }
                }
            }

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

    // Reading Array roiTypeBasedSensitivityModifier from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        roiTypeBasedSensitivityModifierCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, roiTypeBasedSensitivityModifierCount, 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)
        {
            roiTypeBasedSensitivityModifierID = pointerEntry->ID;
            DupObjInfo* roiTypeBasedSensitivityModifierDupInfo = pointerEntry->GetDupObject(roiTypeBasedSensitivityModifierCount, file, line);
            if (roiTypeBasedSensitivityModifierDupInfo != nullptr && roiTypeBasedSensitivityModifierDupInfo->Object != nullptr)
            {
                roiTypeBasedSensitivityModifier = (afglobalelements::ROITypeSensitivityModifier*)roiTypeBasedSensitivityModifierDupInfo->Object;
                if (roiTypeBasedSensitivityModifier == nullptr)
                {
                    if (roiTypeBasedSensitivityModifierDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "roiTypeBasedSensitivityModifier duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            roiTypeBasedSensitivityModifierDupInfo->File, roiTypeBasedSensitivityModifierDupInfo->Line, roiTypeBasedSensitivityModifierDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "roiTypeBasedSensitivityModifier duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            roiTypeBasedSensitivityModifierDupInfo->Line, roiTypeBasedSensitivityModifierDupInfo->RefCount);
                    }
                }
            }

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

    // Reading Array roiSizeBasedSensitivityModifier from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        roiSizeBasedSensitivityModifierCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, roiSizeBasedSensitivityModifierCount, 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)
        {
            roiSizeBasedSensitivityModifierID = pointerEntry->ID;
            DupObjInfo* roiSizeBasedSensitivityModifierDupInfo = pointerEntry->GetDupObject(roiSizeBasedSensitivityModifierCount, file, line);
            if (roiSizeBasedSensitivityModifierDupInfo != nullptr && roiSizeBasedSensitivityModifierDupInfo->Object != nullptr)
            {
                roiSizeBasedSensitivityModifier = (afglobalelements::ROISizeTypeSensitivityModifier*)roiSizeBasedSensitivityModifierDupInfo->Object;
                if (roiSizeBasedSensitivityModifier == nullptr)
                {
                    if (roiSizeBasedSensitivityModifierDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "roiSizeBasedSensitivityModifier duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            roiSizeBasedSensitivityModifierDupInfo->File, roiSizeBasedSensitivityModifierDupInfo->Line, roiSizeBasedSensitivityModifierDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "roiSizeBasedSensitivityModifier duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            roiSizeBasedSensitivityModifierDupInfo->Line, roiSizeBasedSensitivityModifierDupInfo->RefCount);
                    }
                }
            }

            if (roiSizeBasedSensitivityModifier == nullptr)
            {
                if (result && roiSizeBasedSensitivityModifierCount > 0)
                {
                    roiSizeBasedSensitivityModifier = PARAMETER_NEW afglobalelements::ROISizeTypeSensitivityModifier[roiSizeBasedSensitivityModifierCount];
                    (void)pointerEntry->SetDupObject(roiSizeBasedSensitivityModifier, roiSizeBasedSensitivityModifierCount, file, line);
                }
                if (!result || roiSizeBasedSensitivityModifier == nullptr)
                {
                    if (roiSizeBasedSensitivityModifierCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate roiSizeBasedSensitivityModifier\n");
                    }
                    roiSizeBasedSensitivityModifierCount = 0;
                }
                for (UINT32 i = 0; result && i < roiSizeBasedSensitivityModifierCount; i++)
                {
                    result = roiSizeBasedSensitivityModifier[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (roiSizeBasedSensitivityModifier == nullptr)
        {
            roiSizeBasedSensitivityModifierCount = 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 windowBasedSensitivityModifier from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        windowBasedSensitivityModifierCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, windowBasedSensitivityModifierCount, 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)
        {
            windowBasedSensitivityModifierID = pointerEntry->ID;
            DupObjInfo* windowBasedSensitivityModifierDupInfo = pointerEntry->GetDupObject(windowBasedSensitivityModifierCount, file, line);
            if (windowBasedSensitivityModifierDupInfo != nullptr && windowBasedSensitivityModifierDupInfo->Object != nullptr)
            {
                windowBasedSensitivityModifier = (afglobalelements::AFWindowTypeSensitivityModifier*)windowBasedSensitivityModifierDupInfo->Object;
                if (windowBasedSensitivityModifier == nullptr)
                {
                    if (windowBasedSensitivityModifierDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "windowBasedSensitivityModifier duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            windowBasedSensitivityModifierDupInfo->File, windowBasedSensitivityModifierDupInfo->Line, windowBasedSensitivityModifierDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "windowBasedSensitivityModifier duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            windowBasedSensitivityModifierDupInfo->Line, windowBasedSensitivityModifierDupInfo->RefCount);
                    }
                }
            }

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

    // Reading Array expIndexBasedSensitivityModifier from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        expIndexBasedSensitivityModifierCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, expIndexBasedSensitivityModifierCount, 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)
        {
            expIndexBasedSensitivityModifierID = pointerEntry->ID;
            DupObjInfo* expIndexBasedSensitivityModifierDupInfo = pointerEntry->GetDupObject(expIndexBasedSensitivityModifierCount, file, line);
            if (expIndexBasedSensitivityModifierDupInfo != nullptr && expIndexBasedSensitivityModifierDupInfo->Object != nullptr)
            {
                expIndexBasedSensitivityModifier = (afglobalelements::expIdxTypeSensitivityModifier*)expIndexBasedSensitivityModifierDupInfo->Object;
                if (expIndexBasedSensitivityModifier == nullptr)
                {
                    if (expIndexBasedSensitivityModifierDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "expIndexBasedSensitivityModifier duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            expIndexBasedSensitivityModifierDupInfo->File, expIndexBasedSensitivityModifierDupInfo->Line, expIndexBasedSensitivityModifierDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "expIndexBasedSensitivityModifier duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            expIndexBasedSensitivityModifierDupInfo->Line, expIndexBasedSensitivityModifierDupInfo->RefCount);
                    }
                }
            }

            if (expIndexBasedSensitivityModifier == nullptr)
            {
                if (result && expIndexBasedSensitivityModifierCount > 0)
                {
                    expIndexBasedSensitivityModifier = PARAMETER_NEW afglobalelements::expIdxTypeSensitivityModifier[expIndexBasedSensitivityModifierCount];
                    (void)pointerEntry->SetDupObject(expIndexBasedSensitivityModifier, expIndexBasedSensitivityModifierCount, file, line);
                }
                if (!result || expIndexBasedSensitivityModifier == nullptr)
                {
                    if (expIndexBasedSensitivityModifierCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate expIndexBasedSensitivityModifier\n");
                    }
                    expIndexBasedSensitivityModifierCount = 0;
                }
                for (UINT32 i = 0; result && i < expIndexBasedSensitivityModifierCount; i++)
                {
                    result = expIndexBasedSensitivityModifier[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (expIndexBasedSensitivityModifier == nullptr)
        {
            expIndexBasedSensitivityModifierCount = 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 PDConfidenceThresholdsType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool PDConfidenceThresholdsType::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(low);
    PARAMETER_INITIALIZE(mid);
    PARAMETER_INITIALIZE(high);

    SYMBOL_TABLE_ENTRY_READ(entry, result, low, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, mid, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, high, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(normalConfidence);
    PARAMETER_INITIALIZE(highConfidence);
    PARAMETER_INITIALIZE(sensitivityModifiers);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = normalConfidence.Load(entry, alignment);
    }
    if (result)
    {
        result = highConfidence.Load(entry, alignment);
    }
    if (result)
    {
        result = sensitivityModifiers.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(noiseGain);
    PARAMETER_INITIALIZE(minimumConfidence);

    SYMBOL_TABLE_ENTRY_READ(entry, result, noiseGain, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minimumConfidence, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(confidenceEntries);


    // Reading Array confidenceEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        confidenceEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, confidenceEntriesCount, 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)
        {
            confidenceEntriesID = pointerEntry->ID;
            DupObjInfo* confidenceEntriesDupInfo = pointerEntry->GetDupObject(confidenceEntriesCount, file, line);
            if (confidenceEntriesDupInfo != nullptr && confidenceEntriesDupInfo->Object != nullptr)
            {
                confidenceEntries = (chromatixPDConfidenceTableEntryType*)confidenceEntriesDupInfo->Object;
                if (confidenceEntries == nullptr)
                {
                    if (confidenceEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "confidenceEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            confidenceEntriesDupInfo->File, confidenceEntriesDupInfo->Line, confidenceEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "confidenceEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            confidenceEntriesDupInfo->Line, confidenceEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(noiseGain);
    PARAMETER_INITIALIZE(noiseGainMultiplier);

    SYMBOL_TABLE_ENTRY_READ(entry, result, noiseGain, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, noiseGainMultiplier, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(noiseEntries);


    // Reading Array noiseEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        noiseEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, noiseEntriesCount, 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)
        {
            noiseEntriesID = pointerEntry->ID;
            DupObjInfo* noiseEntriesDupInfo = pointerEntry->GetDupObject(noiseEntriesCount, file, line);
            if (noiseEntriesDupInfo != nullptr && noiseEntriesDupInfo->Object != nullptr)
            {
                noiseEntries = (chromatixPDNoiseTableEntryType*)noiseEntriesDupInfo->Object;
                if (noiseEntries == nullptr)
                {
                    if (noiseEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "noiseEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            noiseEntriesDupInfo->File, noiseEntriesDupInfo->Line, noiseEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "noiseEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            noiseEntriesDupInfo->Line, noiseEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(ROILocationY);
    PARAMETER_INITIALIZE(ROILocationX);
    PARAMETER_INITIALIZE(ROINumRows);
    PARAMETER_INITIALIZE(ROINumCols);

    SYMBOL_TABLE_ENTRY_READ(entry, result, ROILocationY, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, ROILocationX, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, ROINumRows, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, ROINumCols, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(Configuration);


    // Reading Array Configuration from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        ConfigurationCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, ConfigurationCount, 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)
        {
            ConfigurationID = pointerEntry->ID;
            DupObjInfo* ConfigurationDupInfo = pointerEntry->GetDupObject(ConfigurationCount, file, line);
            if (ConfigurationDupInfo != nullptr && ConfigurationDupInfo->Object != nullptr)
            {
                Configuration = (chromatixPDROIConfigType*)ConfigurationDupInfo->Object;
                if (Configuration == nullptr)
                {
                    if (ConfigurationDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Configuration duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            ConfigurationDupInfo->File, ConfigurationDupInfo->Line, ConfigurationDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Configuration duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            ConfigurationDupInfo->Line, ConfigurationDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(is2PDEnable);
    PARAMETER_INITIALIZE(ROI);
    PARAMETER_INITIALIZE(focusTable);
    PARAMETER_INITIALIZE(noiseTable);
    PARAMETER_INITIALIZE(confidenceTable);
    PARAMETER_INITIALIZE(confidenceHighTable);
    PARAMETER_INITIALIZE(sensitivityBasedConfidenceTable);
    PARAMETER_INITIALIZE(fallbackConfidence);
    PARAMETER_INITIALIZE(stableTable);
    PARAMETER_INITIALIZE(dofScalerTable);
    PARAMETER_INITIALIZE(focusScan);
    PARAMETER_INITIALIZE(sceneMonitor);
    PARAMETER_INITIALIZE(PDPreprocessing);
    PARAMETER_INITIALIZE(PDInternal);
    PARAMETER_INITIALIZE(PDMultiWindow);
    PARAMETER_INITIALIZE(AdaptivePDOffsetCorrection);
    PARAMETER_INITIALIZE(enablePDEarlyInterrupt);
    PARAMETER_INITIALIZE(dynamicFrameSkipVBlankThreshold);
    PARAMETER_INITIALIZE(ledPdafMaxFrameAllow);
    PARAMETER_INITIALIZE(sparsePDTouchFaceConfidenceThreshold);
    PARAMETER_INITIALIZE(sparsePDTouchFaceLowDefocusConfidenceThreshold);
    PARAMETER_INITIALIZE(enableEnterLSPLowConfidenceHunting);
    PARAMETER_INITIALIZE(LSPLowConfidenceHuntingThreshold);
    PARAMETER_INITIALIZE(face);
    PARAMETER_INITIALIZE(touch);
    PARAMETER_INITIALIZE(track);
    PARAMETER_INITIALIZE(saliency);
    PARAMETER_INITIALIZE(convergeDoneFilter);
    PARAMETER_INITIALIZE(forceEnterFineSearch);
    PARAMETER_INITIALIZE(advancedSparseControl);
    PARAMETER_INITIALIZE(mlpdControl);
    PARAMETER_INITIALIZE(motionConvergeControl);
    PARAMETER_INITIALIZE(temporalFilter);
    PARAMETER_INITIALIZE(multiROISelection);

    result = module_version.Load(entry, alignment);
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, is2PDEnable, alignment)
    if (result)
    {
        result = ROI.Load(entry, alignment);
    }
    if (result)
    {
        result = focusTable.Load(entry, alignment);
    }
    if (result)
    {
        result = noiseTable.Load(entry, alignment);
    }
    if (result)
    {
        result = confidenceTable.Load(entry, alignment);
    }
    if (result)
    {
        result = confidenceHighTable.Load(entry, alignment);
    }
    if (result)
    {
        result = sensitivityBasedConfidenceTable.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, fallbackConfidence, alignment)
    if (result)
    {
        result = stableTable.Load(entry, alignment);
    }
    if (result)
    {
        result = dofScalerTable.Load(entry, alignment);
    }
    if (result)
    {
        result = focusScan.Load(entry, alignment);
    }
    if (result)
    {
        result = sceneMonitor.Load(entry, alignment);
    }
    if (result)
    {
        result = PDPreprocessing.Load(entry, alignment);
    }
    if (result)
    {
        result = PDInternal.Load(entry, alignment);
    }
    if (result)
    {
        result = PDMultiWindow.Load(entry, alignment);
    }
    if (result)
    {
        result = AdaptivePDOffsetCorrection.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enablePDEarlyInterrupt, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, dynamicFrameSkipVBlankThreshold, alignment)
    if (result)
    {
        result = ledPdafMaxFrameAllow.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, sparsePDTouchFaceConfidenceThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, sparsePDTouchFaceLowDefocusConfidenceThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableEnterLSPLowConfidenceHunting, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, LSPLowConfidenceHuntingThreshold, alignment)
    if (result)
    {
        result = face.Load(entry, alignment);
    }
    if (result)
    {
        result = touch.Load(entry, alignment);
    }
    if (result)
    {
        result = track.Load(entry, alignment);
    }
    if (result)
    {
        result = saliency.Load(entry, alignment);
    }
    if (result)
    {
        result = convergeDoneFilter.Load(entry, alignment);
    }
    if (result)
    {
        result = forceEnterFineSearch.Load(entry, alignment);
    }
    if (result)
    {
        result = advancedSparseControl.Load(entry, alignment);
    }
    if (result)
    {
        result = mlpdControl.Load(entry, alignment);
    }
    if (result)
    {
        result = motionConvergeControl.Load(entry, alignment);
    }
    if (result)
    {
        result = temporalFilter.Load(entry, alignment);
    }
    if (result)
    {
        result = multiROISelection.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixPDAFType::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 chromatixPDAFType::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;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(maxFrameCnt);

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(motionConvergeTable);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = motionConvergeTable.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(search);
    PARAMETER_INITIALIZE(monitor);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = search.Load(entry, alignment);
    }
    if (result)
    {
        result = monitor.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(configArr);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)

    // Reading Array configArr from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        configArrCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, configArrCount, 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)
        {
            configArrID = pointerEntry->ID;
            DupObjInfo* configArrDupInfo = pointerEntry->GetDupObject(configArrCount, file, line);
            if (configArrDupInfo != nullptr && configArrDupInfo->Object != nullptr)
            {
                configArr = (chromatixPDAFROISelection*)configArrDupInfo->Object;
                if (configArr == nullptr)
                {
                    if (configArrDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "configArr duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            configArrDupInfo->File, configArrDupInfo->Line, configArrDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "configArr duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            configArrDupInfo->Line, configArrDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDAFTemporalFilterSettingType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDAFTemporalFilterSettingType::Unload(ParameterFileSymbolTable* const __table)
{
    confidenceWeightLUT.Unload(__table);
    lensMoveWeightLUT.Unload(__table);
    frameDelayWeight.Unload(__table);
}

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

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixAdvancedSparsePDControlType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixAdvancedSparsePDControlType::Unload(ParameterFileSymbolTable* const __table)
{
    focusTable.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDSaliencyControlType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDSaliencyControlType::Unload(ParameterFileSymbolTable* const __table)
{
    saliencyROIProcess.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDSaliencyControlType_saliencyROIProcessStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDSaliencyControlType::saliencyROIProcessStruct::Unload(ParameterFileSymbolTable* const __table)
{
    saliencyROIRoughStable.Unload(__table);
    saliencyROIStrictStable.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDTrackControlType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDTrackControlType::Unload(ParameterFileSymbolTable* const __table)
{
    trackROIProcess.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDTrackControlType_trackROIProcessStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDTrackControlType::trackROIProcessStruct::Unload(ParameterFileSymbolTable* const __table)
{
    trackROIRoughStable.Unload(__table);
    trackROIStrictStable.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDFaceControlType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDFaceControlType::Unload(ParameterFileSymbolTable* const __table)
{
    faceROIProcess.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDFaceControlType_faceROIProcessStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDFaceControlType::faceROIProcessStruct::Unload(ParameterFileSymbolTable* const __table)
{
    ROIRoughStable.Unload(__table);
    ROIStrictStable.Unload(__table);
}

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixAdaptivePDOffsetCorrectionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixAdaptivePDOffsetCorrectionType::Unload(ParameterFileSymbolTable* const __table)
{
    luxNodeList.Unload(__table);
    lensPosIntervalList.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDMultiwindowType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDMultiwindowType::Unload(ParameterFileSymbolTable* const __table)
{
    saliencyMWTuning.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDMultiwindowType_saliencyMWTuningStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDMultiwindowType::saliencyMWTuningStruct::Unload(ParameterFileSymbolTable* const __table)
{
    saliencyLUT.Unload(__table);
    phaseDiffLUT.Unload(__table);
    confidenceLUT.Unload(__table);
}

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload confidenceSensitivityModifierArr
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void confidenceSensitivityModifierArr::Unload(ParameterFileSymbolTable* const __table)
{
    if (__table != nullptr && __table->ReleaseDupObject(sceneBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] sceneBasedSensitivityModifier;
    }
    sceneBasedSensitivityModifier = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(roiTypeBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] roiTypeBasedSensitivityModifier;
    }
    roiTypeBasedSensitivityModifier = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(roiSizeBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] roiSizeBasedSensitivityModifier;
    }
    roiSizeBasedSensitivityModifier = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(zoomBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] zoomBasedSensitivityModifier;
    }
    zoomBasedSensitivityModifier = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(windowBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] windowBasedSensitivityModifier;
    }
    windowBasedSensitivityModifier = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(expIndexBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] expIndexBasedSensitivityModifier;
    }
    expIndexBasedSensitivityModifier = nullptr;
    if (__table != nullptr && __table->ReleaseDupObject(gainBasedSensitivityModifier))
    {
        PARAMETER_DELETE[] gainBasedSensitivityModifier;
    }
    gainBasedSensitivityModifier = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload sensitivityBasedConfidenceTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void sensitivityBasedConfidenceTableType::Unload(ParameterFileSymbolTable* const __table)
{
    sensitivityModifiers.Unload(__table);
}

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixPDAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDAFType::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    ROI.Unload(__table);
    focusTable.Unload(__table);
    noiseTable.Unload(__table);
    confidenceTable.Unload(__table);
    confidenceHighTable.Unload(__table);
    sensitivityBasedConfidenceTable.Unload(__table);
    stableTable.Unload(__table);
    dofScalerTable.Unload(__table);
    PDMultiWindow.Unload(__table);
    AdaptivePDOffsetCorrection.Unload(__table);
    face.Unload(__table);
    track.Unload(__table);
    saliency.Unload(__table);
    advancedSparseControl.Unload(__table);
    motionConvergeControl.Unload(__table);
    temporalFilter.Unload(__table);
    multiROISelection.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload motionConvergeControlStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDAFType::motionConvergeControlStruct::Unload(ParameterFileSymbolTable* const __table)
{
    motionConvergeTable.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload temporalFilterStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixPDAFType::temporalFilterStruct::Unload(ParameterFileSymbolTable* const __table)
{
    search.Unload(__table);
    monitor.Unload(__table);
}

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Create module, and return a new object
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ParameterModule* chromatixPDAFTypeClass::Create(
    ModuleData*    moduleData,
    DefaultModule* const defModule) const
{
    chromatixPDAFTypeClass* 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 = (chromatixPDAFTypeClass*)module;
        }
        else
        {
            cls = PARAMETER_NEW chromatixPDAFTypeClass(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 chromatixPDAFTypeClass, binary version (%lld) does not match source version (%lld)\n",
            moduleData->Version.Value, Version.Value);
    }
    else
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatixPDAFTypeClass, binary name (%s) does not match source name (%s)\n",
            moduleData->Type, Type);
    }

    return (ParameterModule*)cls;
}

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

    if (!Loaded)
    {
        BYTE const alignment = table->Alignment;
        chromatixPDAFTypeClass* 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, "chromatixPDAFTypeClass::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 chromatixPDAFTypeClass::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 chromatixPDAFTypeClass::Release()
{
    ParameterModule::Release();
}

AFPDAFELEMENTS_NAMESPACE_END
