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

#include "aecflash.h"
#include "parametersetmanager.h"

AECFLASH_NAMESPACE_BEGIN

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

bool LEDInlineCalibType::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, "triggerIndex") == 0)
    {
        ParameterUtils::DoubleToString((double)triggerIndex, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "refRange") == 0)
    {
        ParameterUtils::DoubleToString((double)refRange, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "refRegionPCT") == 0)
    {
        ParameterUtils::DoubleToString((double)refRegionPCT, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "validRefCount") == 0)
    {
        ParameterUtils::DoubleToString((double)validRefCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "distanceRatioMin") == 0)
    {
        ParameterUtils::DoubleToString((double)distanceRatioMin, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "distanceRatioMax") == 0)
    {
        ParameterUtils::DoubleToString((double)distanceRatioMax, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "angleShiftMax") == 0)
    {
        ParameterUtils::DoubleToString((double)angleShiftMax, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minKneeCnt") == 0)
    {
        ParameterUtils::DoubleToString((double)minKneeCnt, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxZoneCnt") == 0)
    {
        ParameterUtils::DoubleToString((double)maxZoneCnt, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confidencePctThr") == 0)
    {
        ParameterUtils::DoubleToString((double)confidencePctThr, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numOfFactoringRegions") == 0)
    {
        ParameterUtils::DoubleToString((double)numOfFactoringRegions, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "LEDInlineCalibTarget") == 0)
    {
        __result = LEDInlineCalibTarget.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool LEDInlineCalibType::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, "triggerIndex") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            triggerIndex = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "refRange") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            refRange = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "refRegionPCT") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            refRegionPCT = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "validRefCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            validRefCount = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "distanceRatioMin") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            distanceRatioMin = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "distanceRatioMax") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            distanceRatioMax = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "angleShiftMax") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            angleShiftMax = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minKneeCnt") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minKneeCnt = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxZoneCnt") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxZoneCnt = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidencePctThr") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confidencePctThr = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numOfFactoringRegions") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numOfFactoringRegions = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LEDInlineCalibTarget") == 0)
    {
        __result = LEDInlineCalibTarget.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool LEDMeasurementType::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, "frameErrAllowance") == 0)
    {
        ParameterUtils::DoubleToString((double)frameErrAllowance, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "numOfFrames") == 0)
    {
        ParameterUtils::DoubleToString((double)numOfFrames, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxNumOfFrames") == 0)
    {
        ParameterUtils::DoubleToString((double)maxNumOfFrames, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxNumOfExtraAttempts") == 0)
    {
        ParameterUtils::DoubleToString((double)maxNumOfExtraAttempts, __value, __size, 0);
        __result = true;
    }

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

bool LEDMixCalibType::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, "numOfCalibration") == 0)
    {
        ParameterUtils::DoubleToString((double)numOfCalibration, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableCornerSampleScreen") == 0)
    {
        ParameterUtils::DoubleToString((double)enableCornerSampleScreen, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "calibEntries") == 0)
    {
        if (__index < calibEntriesCount)
        {
            __result = calibEntries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "statsRatioOKRange") == 0)
    {
        if (__index < statsRatioOKRangeCount)
        {
            __result = statsRatioOKRange[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "fixedExpIndex") == 0)
    {
        if (__index < fixedExpIndexCount)
        {
            ParameterUtils::DoubleToString((double)fixedExpIndex[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < fixedExpIndexCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)fixedExpIndex[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool LEDMixCalibType::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, "numOfCalibration") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numOfCalibration = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableCornerSampleScreen") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableCornerSampleScreen = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "calibEntries") == 0)
    {
        if (__index < calibEntriesCount)
        {
            __result = calibEntries[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "statsRatioOKRange") == 0)
    {
        if (__index < statsRatioOKRangeCount)
        {
            __result = statsRatioOKRange[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "fixedExpIndex") == 0)
    {
        if (__index < fixedExpIndexCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                fixedExpIndex[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

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

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

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

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

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

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

    return __result;
}

bool LEDMixType::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, "LED1Setting") == 0)
    {
        ParameterUtils::DoubleToString((double)LED1Setting, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "LED2Setting") == 0)
    {
        ParameterUtils::DoubleToString((double)LED2Setting, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "RGRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)RGRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BGRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)BGRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "flux") == 0)
    {
        ParameterUtils::DoubleToString((double)flux, __value, __size);
        __result = true;
    }

    return __result;
}

bool LEDMixType::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, "LED1Setting") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            LED1Setting = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LED2Setting") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            LED2Setting = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "RGRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            RGRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BGRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            BGRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "flux") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            flux = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

bool LEDMatchTableType::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, "enableDualLED") == 0)
    {
        ParameterUtils::DoubleToString((double)enableDualLED, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dualLEDIntersectSlope") == 0)
    {
        ParameterUtils::DoubleToString((double)dualLEDIntersectSlope, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "LEDPowerSize") == 0)
    {
        ParameterUtils::DoubleToString((double)LEDPowerSize, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "LEDMixSize") == 0)
    {
        ParameterUtils::DoubleToString((double)LEDMixSize, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "CCTTables") == 0)
    {
        if (__index < CCTTablesCount)
        {
            __result = CCTTables[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "CCTTableCalibration") == 0)
    {
        __result = CCTTableCalibration.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "LEDMeasConfig") == 0)
    {
        __result = LEDMeasConfig.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enableDerating") == 0)
    {
        ParameterUtils::DoubleToString((double)enableDerating, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool LEDMatchTableType::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, "enableDualLED") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableDualLED = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dualLEDIntersectSlope") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dualLEDIntersectSlope = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LEDPowerSize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            LEDPowerSize = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LEDMixSize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            LEDMixSize = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "CCTTables") == 0)
    {
        if (__index < CCTTablesCount)
        {
            __result = CCTTables[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "CCTTableCalibration") == 0)
    {
        __result = CCTTableCalibration.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "LEDMeasConfig") == 0)
    {
        __result = LEDMeasConfig.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enableDerating") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableDerating = (BOOL)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

bool FlashExtensionType::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, "flashLuxTrigger") == 0)
    {
        __result = flashLuxTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "flashFDRequestDelayLuxTrigger") == 0)
    {
        __result = flashFDRequestDelayLuxTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "LEDTable") == 0)
    {
        __result = LEDTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enableForceAFInLEDOnMode") == 0)
    {
        ParameterUtils::DoubleToString((double)enableForceAFInLEDOnMode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "LEDInlineCalib") == 0)
    {
        __result = LEDInlineCalib.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool FlashExtensionType::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, "flashLuxTrigger") == 0)
    {
        __result = flashLuxTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "flashFDRequestDelayLuxTrigger") == 0)
    {
        __result = flashFDRequestDelayLuxTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "LEDTable") == 0)
    {
        __result = LEDTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enableForceAFInLEDOnMode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableForceAFInLEDOnMode = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LEDInlineCalib") == 0)
    {
        __result = LEDInlineCalib.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool FlashArbitrationType::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, "expTableIDPreFlash") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            expTableIDPreFlash = (aecglobalelements::ExposureTableIDType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "expTableIDMainFlash") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            expTableIDMainFlash = (aecglobalelements::ExposureTableIDType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "expTableIDFlashMeasurement") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            expTableIDFlashMeasurement = (aecglobalelements::ExposureTableIDType)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool TorchConvType::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, "enableTorchConvergence") == 0)
    {
        ParameterUtils::DoubleToString((double)enableTorchConvergence, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tolMultUnitStepSize") == 0)
    {
        ParameterUtils::DoubleToString((double)tolMultUnitStepSize, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameSkipMethod") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)frameSkipMethod, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aggressiveness") == 0)
    {
        ParameterUtils::DoubleToString((double)aggressiveness, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "startupAggressiveness") == 0)
    {
        ParameterUtils::DoubleToString((double)startupAggressiveness, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ADRCConvSpeed") == 0)
    {
        ParameterUtils::DoubleToString((double)ADRCConvSpeed, __value, __size);
        __result = true;
    }

    return __result;
}

bool TorchConvType::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, "enableTorchConvergence") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableTorchConvergence = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tolMultUnitStepSize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tolMultUnitStepSize = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameSkipMethod") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameSkipMethod = (aecglobalelements::ConvFrameSkipType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aggressiveness") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aggressiveness = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "startupAggressiveness") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            startupAggressiveness = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ADRCConvSpeed") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ADRCConvSpeed = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool DynamicEnterSkip::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, "enableDynamicEnterSkip") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableDynamicEnterSkip = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "preflashMinFrameSkip") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            preflashMinFrameSkip = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FPSRange") == 0)
    {
        __result = FPSRange.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool PreFlashConvergenceType::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, "frameSkipMethod") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)frameSkipMethod, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aggressiveness") == 0)
    {
        ParameterUtils::DoubleToString((double)aggressiveness, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "settledFrameCountThres") == 0)
    {
        ParameterUtils::DoubleToString((double)settledFrameCountThres, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "preflashFrameCounterEnter") == 0)
    {
        __result = preflashFrameCounterEnter.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "preflashFrameCounterExit") == 0)
    {
        __result = preflashFrameCounterExit.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "dynamicEnterSkip") == 0)
    {
        __result = dynamicEnterSkip.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool PreFlashConvergenceType::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, "frameSkipMethod") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameSkipMethod = (aecglobalelements::ConvFrameSkipType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aggressiveness") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aggressiveness = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "settledFrameCountThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            settledFrameCountThres = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "preflashFrameCounterEnter") == 0)
    {
        __result = preflashFrameCounterEnter.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "preflashFrameCounterExit") == 0)
    {
        __result = preflashFrameCounterExit.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "dynamicEnterSkip") == 0)
    {
        __result = dynamicEnterSkip.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool FlashConvergenceType::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, "flashTuningBreak") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            flashTuningBreak = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "preflashConv") == 0)
    {
        __result = preflashConv.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "flashMeasurementConv") == 0)
    {
        __result = flashMeasurementConv.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "torchConv") == 0)
    {
        __result = torchConv.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

bool AECTrackerFlashType::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, "enableTrackerFlash") == 0)
    {
        ParameterUtils::DoubleToString((double)enableTrackerFlash, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ledTrackerWeight") == 0)
    {
        __result = ledTrackerWeight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "ledTrackerSize") == 0)
    {
        __result = ledTrackerSize.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "TrackerFlashFrameCount") == 0)
    {
        ParameterUtils::DoubleToString((double)TrackerFlashFrameCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TrackerFlashLumaTarget") == 0)
    {
        ParameterUtils::DoubleToString((double)TrackerFlashLumaTarget, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "trackerSizeExpEffect") == 0)
    {
        __result = trackerSizeExpEffect.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "statsUpdateDelayTimeEnter") == 0)
    {
        ParameterUtils::DoubleToString((double)statsUpdateDelayTimeEnter, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "statsUpdateDelayTimeExit") == 0)
    {
        ParameterUtils::DoubleToString((double)statsUpdateDelayTimeExit, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dynamicTrackerDelay") == 0)
    {
        __result = dynamicTrackerDelay.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool AECTrackerFlashType::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, "enableTrackerFlash") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableTrackerFlash = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ledTrackerWeight") == 0)
    {
        __result = ledTrackerWeight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "ledTrackerSize") == 0)
    {
        __result = ledTrackerSize.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "TrackerFlashFrameCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TrackerFlashFrameCount = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TrackerFlashLumaTarget") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TrackerFlashLumaTarget = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "trackerSizeExpEffect") == 0)
    {
        __result = trackerSizeExpEffect.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "statsUpdateDelayTimeEnter") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            statsUpdateDelayTimeEnter = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "statsUpdateDelayTimeExit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            statsUpdateDelayTimeExit = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dynamicTrackerDelay") == 0)
    {
        __result = dynamicTrackerDelay.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

bool AECFaceDetectionFlashType::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, "enableFDFlash") == 0)
    {
        ParameterUtils::DoubleToString((double)enableFDFlash, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ledFaceWeight") == 0)
    {
        __result = ledFaceWeight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "ledFaceSize") == 0)
    {
        __result = ledFaceSize.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "FDFlashFrameCount") == 0)
    {
        ParameterUtils::DoubleToString((double)FDFlashFrameCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "FDFlashLumaTarget") == 0)
    {
        ParameterUtils::DoubleToString((double)FDFlashLumaTarget, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "faceSizeExpEffect") == 0)
    {
        __result = faceSizeExpEffect.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "statsUpdateDelayTimeEnter") == 0)
    {
        ParameterUtils::DoubleToString((double)statsUpdateDelayTimeEnter, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "statsUpdateDelayTimeExit") == 0)
    {
        ParameterUtils::DoubleToString((double)statsUpdateDelayTimeExit, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dynamicDelay") == 0)
    {
        __result = dynamicDelay.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool AECFaceDetectionFlashType::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, "enableFDFlash") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFDFlash = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ledFaceWeight") == 0)
    {
        __result = ledFaceWeight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "ledFaceSize") == 0)
    {
        __result = ledFaceSize.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "FDFlashFrameCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FDFlashFrameCount = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FDFlashLumaTarget") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            FDFlashLumaTarget = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "faceSizeExpEffect") == 0)
    {
        __result = faceSizeExpEffect.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "statsUpdateDelayTimeEnter") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            statsUpdateDelayTimeEnter = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "statsUpdateDelayTimeExit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            statsUpdateDelayTimeExit = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dynamicDelay") == 0)
    {
        __result = dynamicDelay.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool FlashDynamicMinAdjType::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, "enableDynamicMinAdj") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableDynamicMinAdj = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "percThresh") == 0)
    {
        __result = percThresh.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "minLumaAdjEnd") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minLumaAdjEnd = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool FlashStatsPreprocessingType::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, "thresBrightLevelDiff") == 0)
    {
        ParameterUtils::DoubleToString((double)thresBrightLevelDiff, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thresBrightLevel") == 0)
    {
        ParameterUtils::DoubleToString((double)thresBrightLevel, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thresBrightSatDiff") == 0)
    {
        ParameterUtils::DoubleToString((double)thresBrightSatDiff, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thresBrightSat") == 0)
    {
        ParameterUtils::DoubleToString((double)thresBrightSat, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minLuma") == 0)
    {
        ParameterUtils::DoubleToString((double)minLuma, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minLumaAdj") == 0)
    {
        ParameterUtils::DoubleToString((double)minLumaAdj, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minLumaAdjDynamic") == 0)
    {
        __result = minLumaAdjDynamic.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool FlashStatsPreprocessingType::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, "thresBrightLevelDiff") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresBrightLevelDiff = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thresBrightLevel") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresBrightLevel = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thresBrightSatDiff") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresBrightSatDiff = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thresBrightSat") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thresBrightSat = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minLuma") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minLuma = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minLumaAdj") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minLumaAdj = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minLumaAdjDynamic") == 0)
    {
        __result = minLumaAdjDynamic.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

bool SmartFlashType::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, "enableSmartFlashEst") == 0)
    {
        ParameterUtils::DoubleToString((double)enableSmartFlashEst, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "smartFlashEstStrength") == 0)
    {
        ParameterUtils::DoubleToString((double)smartFlashEstStrength, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minOffStats") == 0)
    {
        ParameterUtils::DoubleToString((double)minOffStats, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "kFloorPct") == 0)
    {
        ParameterUtils::DoubleToString((double)kFloorPct, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "satPreventStrength") == 0)
    {
        ParameterUtils::DoubleToString((double)satPreventStrength, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableSpeckleHandling") == 0)
    {
        ParameterUtils::DoubleToString((double)enableSpeckleHandling, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "speckleSatPctRange") == 0)
    {
        __result = speckleSatPctRange.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool SmartFlashType::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, "enableSmartFlashEst") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableSmartFlashEst = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "smartFlashEstStrength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smartFlashEstStrength = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minOffStats") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minOffStats = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "kFloorPct") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            kFloorPct = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "satPreventStrength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            satPreventStrength = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableSpeckleHandling") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableSpeckleHandling = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "speckleSatPctRange") == 0)
    {
        __result = speckleSatPctRange.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

bool FlashMeteringType::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, "flashLumaTarget") == 0)
    {
        __result = flashLumaTarget.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "smartFlash") == 0)
    {
        __result = smartFlash.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "statsPreprocessing") == 0)
    {
        __result = statsPreprocessing.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "FDFlash") == 0)
    {
        __result = FDFlash.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "TrackerFlash") == 0)
    {
        __result = TrackerFlash.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool FlashMeteringType::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, "flashLumaTarget") == 0)
    {
        __result = flashLumaTarget.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "smartFlash") == 0)
    {
        __result = smartFlash.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "statsPreprocessing") == 0)
    {
        __result = statsPreprocessing.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "FDFlash") == 0)
    {
        __result = FDFlash.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "TrackerFlash") == 0)
    {
        __result = TrackerFlash.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

bool AECFlashType::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, "flashMtr") == 0)
    {
        __result = flashMtr.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "flashConv") == 0)
    {
        __result = flashConv.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "flashArb") == 0)
    {
        __result = flashArb.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "flashExt") == 0)
    {
        __result = flashExt.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool AECFlashType::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, "flashMtr") == 0)
    {
        __result = flashMtr.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "flashConv") == 0)
    {
        __result = flashConv.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "flashArb") == 0)
    {
        __result = flashArb.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "flashExt") == 0)
    {
        __result = flashExt.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

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


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AECFlashTypeClass::AECFlashTypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(flashMtr);
    PARAMETER_INITIALIZE(flashConv);
    PARAMETER_INITIALIZE(flashArb);
    PARAMETER_INITIALIZE(flashExt);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AECFlashTypeClass::AECFlashTypeClass(
    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(flashMtr);
    PARAMETER_INITIALIZE(flashConv);
    PARAMETER_INITIALIZE(flashArb);
    PARAMETER_INITIALIZE(flashExt);
}

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

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

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

    PARAMETER_INITIALIZE(distancePCT);
    PARAMETER_INITIALIZE(angleShiftPCT);

    SYMBOL_TABLE_ENTRY_READ(entry, result, distancePCT, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, angleShiftPCT, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

    result = zoneTrigger.Load(entry, alignment);
    if (result)
    {
        result = zoneData.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(LEDInlineCalibTargetZone);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(triggerIndex);
    PARAMETER_INITIALIZE(refRange);
    PARAMETER_INITIALIZE(refRegionPCT);
    PARAMETER_INITIALIZE(validRefCount);
    PARAMETER_INITIALIZE(distanceRatioMin);
    PARAMETER_INITIALIZE(distanceRatioMax);
    PARAMETER_INITIALIZE(angleShiftMax);
    PARAMETER_INITIALIZE(minKneeCnt);
    PARAMETER_INITIALIZE(maxZoneCnt);
    PARAMETER_INITIALIZE(confidencePctThr);
    PARAMETER_INITIALIZE(numOfFactoringRegions);
    PARAMETER_INITIALIZE(LEDInlineCalibTarget);

    SYMBOL_TABLE_ENTRY_READ(entry, result, triggerIndex, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, refRange, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, refRegionPCT, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, validRefCount, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, distanceRatioMin, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, distanceRatioMax, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, angleShiftMax, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minKneeCnt, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxZoneCnt, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, confidencePctThr, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numOfFactoringRegions, alignment)
    if (result)
    {
        result = LEDInlineCalibTarget.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(frameErrAllowance);
    PARAMETER_INITIALIZE(numOfFrames);
    PARAMETER_INITIALIZE(maxNumOfFrames);
    PARAMETER_INITIALIZE(maxNumOfExtraAttempts);

    SYMBOL_TABLE_ENTRY_READ(entry, result, frameErrAllowance, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numOfFrames, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxNumOfFrames, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxNumOfExtraAttempts, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(RGRatioOKRange);
    PARAMETER_INITIALIZE(BGRatioOKRange);

    result = RGRatioOKRange.Load(entry, alignment);
    if (result)
    {
        result = BGRatioOKRange.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(LEDPowerIndex);
    PARAMETER_INITIALIZE(LEDMixIndex);

    SYMBOL_TABLE_ENTRY_READ(entry, result, LEDPowerIndex, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, LEDMixIndex, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(numOfCalibration);
    PARAMETER_INITIALIZE(enableCornerSampleScreen);
    PARAMETER_INITIALIZE(calibEntries);
    PARAMETER_INITIALIZE(statsRatioOKRange);
    PARAMETER_INITIALIZE(fixedExpIndex);

    SYMBOL_TABLE_ENTRY_READ(entry, result, numOfCalibration, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableCornerSampleScreen, alignment)

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

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

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

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(LED1Setting);
    PARAMETER_INITIALIZE(LED2Setting);
    PARAMETER_INITIALIZE(RGRatio);
    PARAMETER_INITIALIZE(BGRatio);
    PARAMETER_INITIALIZE(flux);

    SYMBOL_TABLE_ENTRY_READ(entry, result, LED1Setting, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, LED2Setting, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, RGRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, BGRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, flux, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enableDualLED);
    PARAMETER_INITIALIZE(dualLEDIntersectSlope);
    PARAMETER_INITIALIZE(LEDPowerSize);
    PARAMETER_INITIALIZE(LEDMixSize);
    PARAMETER_INITIALIZE(CCTTables);
    PARAMETER_INITIALIZE(CCTTableCalibration);
    PARAMETER_INITIALIZE(LEDMeasConfig);
    PARAMETER_INITIALIZE(enableDerating);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableDualLED, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, dualLEDIntersectSlope, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, LEDPowerSize, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, LEDMixSize, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(flashLuxTrigger);
    PARAMETER_INITIALIZE(flashFDRequestDelayLuxTrigger);
    PARAMETER_INITIALIZE(LEDTable);
    PARAMETER_INITIALIZE(enableForceAFInLEDOnMode);
    PARAMETER_INITIALIZE(LEDInlineCalib);

    result = flashLuxTrigger.Load(entry, alignment);
    if (result)
    {
        result = flashFDRequestDelayLuxTrigger.Load(entry, alignment);
    }
    if (result)
    {
        result = LEDTable.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableForceAFInLEDOnMode, alignment)
    if (result)
    {
        result = LEDInlineCalib.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(expTableIDPreFlash);
    PARAMETER_INITIALIZE(expTableIDMainFlash);
    PARAMETER_INITIALIZE(expTableIDFlashMeasurement);

    SYMBOL_TABLE_ENTRY_READ(entry, result, expTableIDPreFlash, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, expTableIDMainFlash, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, expTableIDFlashMeasurement, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enableTorchConvergence);
    PARAMETER_INITIALIZE(tolMultUnitStepSize);
    PARAMETER_INITIALIZE(frameSkipMethod);
    PARAMETER_INITIALIZE(aggressiveness);
    PARAMETER_INITIALIZE(startupAggressiveness);
    PARAMETER_INITIALIZE(ADRCConvSpeed);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableTorchConvergence, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tolMultUnitStepSize, alignment)
    if (result)
    {
        result = aecglobalelements::ReadEnum_ConvFrameSkipType(entry, frameSkipMethod, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, aggressiveness, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, startupAggressiveness, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, ADRCConvSpeed, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enableDynamicEnterSkip);
    PARAMETER_INITIALIZE(preflashMinFrameSkip);
    PARAMETER_INITIALIZE(FPSRange);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableDynamicEnterSkip, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, preflashMinFrameSkip, alignment)
    if (result)
    {
        result = FPSRange.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(frameSkipMethod);
    PARAMETER_INITIALIZE(aggressiveness);
    PARAMETER_INITIALIZE(settledFrameCountThres);
    PARAMETER_INITIALIZE(preflashFrameCounterEnter);
    PARAMETER_INITIALIZE(preflashFrameCounterExit);
    PARAMETER_INITIALIZE(dynamicEnterSkip);

    result = aecglobalelements::ReadEnum_ConvFrameSkipType(entry, frameSkipMethod, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, aggressiveness, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, settledFrameCountThres, alignment)
    if (result)
    {
        result = preflashFrameCounterEnter.Load(entry, alignment);
    }
    if (result)
    {
        result = preflashFrameCounterExit.Load(entry, alignment);
    }
    if (result)
    {
        result = dynamicEnterSkip.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(flashTuningBreak);
    PARAMETER_INITIALIZE(preflashConv);
    PARAMETER_INITIALIZE(flashMeasurementConv);
    PARAMETER_INITIALIZE(torchConv);

    SYMBOL_TABLE_ENTRY_READ(entry, result, flashTuningBreak, alignment)
    if (result)
    {
        result = preflashConv.Load(entry, alignment);
    }
    if (result)
    {
        result = flashMeasurementConv.Load(entry, alignment);
    }
    if (result)
    {
        result = torchConv.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableTrackerDynamicDelay);
    PARAMETER_INITIALIZE(minLumaToSkipPreTracker);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableTrackerDynamicDelay, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minLumaToSkipPreTracker, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enableTrackerFlash);
    PARAMETER_INITIALIZE(ledTrackerWeight);
    PARAMETER_INITIALIZE(ledTrackerSize);
    PARAMETER_INITIALIZE(TrackerFlashFrameCount);
    PARAMETER_INITIALIZE(TrackerFlashLumaTarget);
    PARAMETER_INITIALIZE(trackerSizeExpEffect);
    PARAMETER_INITIALIZE(statsUpdateDelayTimeEnter);
    PARAMETER_INITIALIZE(statsUpdateDelayTimeExit);
    PARAMETER_INITIALIZE(dynamicTrackerDelay);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableTrackerFlash, alignment)
    if (result)
    {
        result = ledTrackerWeight.Load(entry, alignment);
    }
    if (result)
    {
        result = ledTrackerSize.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, TrackerFlashFrameCount, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TrackerFlashLumaTarget, alignment)
    if (result)
    {
        result = trackerSizeExpEffect.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, statsUpdateDelayTimeEnter, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, statsUpdateDelayTimeExit, alignment)
    if (result)
    {
        result = dynamicTrackerDelay.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableFDDynamicDelay);
    PARAMETER_INITIALIZE(minLumaToSkipPreFD);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFDDynamicDelay, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minLumaToSkipPreFD, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enableFDFlash);
    PARAMETER_INITIALIZE(ledFaceWeight);
    PARAMETER_INITIALIZE(ledFaceSize);
    PARAMETER_INITIALIZE(FDFlashFrameCount);
    PARAMETER_INITIALIZE(FDFlashLumaTarget);
    PARAMETER_INITIALIZE(faceSizeExpEffect);
    PARAMETER_INITIALIZE(statsUpdateDelayTimeEnter);
    PARAMETER_INITIALIZE(statsUpdateDelayTimeExit);
    PARAMETER_INITIALIZE(dynamicDelay);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFDFlash, alignment)
    if (result)
    {
        result = ledFaceWeight.Load(entry, alignment);
    }
    if (result)
    {
        result = ledFaceSize.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, FDFlashFrameCount, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, FDFlashLumaTarget, alignment)
    if (result)
    {
        result = faceSizeExpEffect.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, statsUpdateDelayTimeEnter, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, statsUpdateDelayTimeExit, alignment)
    if (result)
    {
        result = dynamicDelay.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableDynamicMinAdj);
    PARAMETER_INITIALIZE(percThresh);
    PARAMETER_INITIALIZE(minLumaAdjEnd);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableDynamicMinAdj, alignment)
    if (result)
    {
        result = percThresh.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, minLumaAdjEnd, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(thresBrightLevelDiff);
    PARAMETER_INITIALIZE(thresBrightLevel);
    PARAMETER_INITIALIZE(thresBrightSatDiff);
    PARAMETER_INITIALIZE(thresBrightSat);
    PARAMETER_INITIALIZE(minLuma);
    PARAMETER_INITIALIZE(minLumaAdj);
    PARAMETER_INITIALIZE(minLumaAdjDynamic);

    SYMBOL_TABLE_ENTRY_READ(entry, result, thresBrightLevelDiff, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thresBrightLevel, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thresBrightSatDiff, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thresBrightSat, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minLuma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minLumaAdj, alignment)
    if (result)
    {
        result = minLumaAdjDynamic.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableSmartFlashEst);
    PARAMETER_INITIALIZE(smartFlashEstStrength);
    PARAMETER_INITIALIZE(minOffStats);
    PARAMETER_INITIALIZE(kFloorPct);
    PARAMETER_INITIALIZE(satPreventStrength);
    PARAMETER_INITIALIZE(enableSpeckleHandling);
    PARAMETER_INITIALIZE(speckleSatPctRange);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableSmartFlashEst, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, smartFlashEstStrength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minOffStats, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, kFloorPct, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, satPreventStrength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableSpeckleHandling, alignment)
    if (result)
    {
        result = speckleSatPctRange.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableFlashTarget);
    PARAMETER_INITIALIZE(flashTarget);
    PARAMETER_INITIALIZE(flashInfluenceTargetInterpolation);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFlashTarget, alignment)
    if (result)
    {
        result = flashTarget.Load(entry, alignment);
    }
    if (result)
    {
        result = flashInfluenceTargetInterpolation.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(flashLumaTarget);
    PARAMETER_INITIALIZE(smartFlash);
    PARAMETER_INITIALIZE(statsPreprocessing);
    PARAMETER_INITIALIZE(FDFlash);
    PARAMETER_INITIALIZE(TrackerFlash);

    result = flashLumaTarget.Load(entry, alignment);
    if (result)
    {
        result = smartFlash.Load(entry, alignment);
    }
    if (result)
    {
        result = statsPreprocessing.Load(entry, alignment);
    }
    if (result)
    {
        result = FDFlash.Load(entry, alignment);
    }
    if (result)
    {
        result = TrackerFlash.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(flashMtr);
    PARAMETER_INITIALIZE(flashConv);
    PARAMETER_INITIALIZE(flashArb);
    PARAMETER_INITIALIZE(flashExt);

    result = module_version.Load(entry, alignment);
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = flashMtr.Load(entry, alignment);
    }
    if (result)
    {
        result = flashConv.Load(entry, alignment);
    }
    if (result)
    {
        result = flashArb.Load(entry, alignment);
    }
    if (result)
    {
        result = flashExt.Load(entry, alignment);
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool AECFlashType::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 AECFlashType::parameter_versionStruct::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(revision);


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

    return result;
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LEDInlineCalibType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LEDInlineCalibType::Unload(ParameterFileSymbolTable* const __table)
{
    LEDInlineCalibTarget.Unload(__table);
}

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload FlashExtensionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FlashExtensionType::Unload(ParameterFileSymbolTable* const __table)
{
    LEDTable.Unload(__table);
    LEDInlineCalib.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload FlashLumaTargetType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FlashLumaTargetType::Unload(ParameterFileSymbolTable* const __table)
{
    flashTarget.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload FlashMeteringType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FlashMeteringType::Unload(ParameterFileSymbolTable* const __table)
{
    flashLumaTarget.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AECFlashType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECFlashType::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    flashMtr.Unload(__table);
    flashExt.Unload(__table);
}

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

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

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

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

    return (ParameterModule*)cls;
}

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

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

AECFLASH_NAMESPACE_END
