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

#include "afdtuning.h"
#include "parametersetmanager.h"

AFDTUNING_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool afd_param_extension_type::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, "extension_param") == 0)
    {
        if (__index < extension_paramCount)
        {
            __result = extension_param[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable_window_config") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable_window_config = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "make_skip_multiple_2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            make_skip_multiple_2 = (BOOL)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable_rolling_strength") == 0)
    {
        ParameterUtils::DoubleToString((double)enable_rolling_strength, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "strength_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)strength_threshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "sumAvgForPeakEnable") == 0)
    {
        ParameterUtils::DoubleToString((double)sumAvgForPeakEnable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "coutNumForPeakSum") == 0)
    {
        ParameterUtils::DoubleToString((double)coutNumForPeakSum, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fakePeakSumAvgThres") == 0)
    {
        ParameterUtils::DoubleToString((double)fakePeakSumAvgThres, __value, __size);
        __result = true;
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable_rolling_strength") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable_rolling_strength = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "strength_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            strength_threshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sumAvgForPeakEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sumAvgForPeakEnable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "coutNumForPeakSum") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            coutNumForPeakSum = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fakePeakSumAvgThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fakePeakSumAvgThres = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool trigger_point_type::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, "lux_index_start") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lux_index_start = (INT64)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lux_index_end") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lux_index_end = (INT64)dblValue; 
        }
    }

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

bool af_status_check_type::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, "af_status_select") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)af_status_select, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stable_lens_pos_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)stable_lens_pos_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stable_lens_pos_frame_count") == 0)
    {
        ParameterUtils::DoubleToString((double)stable_lens_pos_frame_count, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool af_status_check_type::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, "af_status_select") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            af_status_select = (af_status_select_type)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stable_lens_pos_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stable_lens_pos_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stable_lens_pos_frame_count") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stable_lens_pos_frame_count = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool chromatix_afd_rolling_data_type::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, "std_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)std_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "percent_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)percent_threshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "diff_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)diff_threshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_peaks_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)num_peaks_threshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_flicker_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)num_flicker_threshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "band_dist_comp") == 0)
    {
        ParameterUtils::DoubleToString((double)band_dist_comp, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "band_range_min") == 0)
    {
        ParameterUtils::DoubleToString((double)band_range_min, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "band_range_max") == 0)
    {
        ParameterUtils::DoubleToString((double)band_range_max, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)col_skip_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_pattern") == 0)
    {
        if (__index < 16)
        {
            ParameterUtils::DoubleToString((double)col_skip_pattern[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 16; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)col_skip_pattern[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "downsampling_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)downsampling_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_bands_dependent_downsampling") == 0)
    {
        if (__index < num_bands_dependent_downsamplingCount)
        {
            __result = num_bands_dependent_downsampling[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "bandStrength") == 0)
    {
        __result = bandStrength.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatix_afd_rolling_data_type::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, "std_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            std_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "percent_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            percent_threshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "diff_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            diff_threshold = (UINT64)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_peaks_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_peaks_threshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_flicker_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_flicker_threshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "band_dist_comp") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            band_dist_comp = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "band_range_min") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            band_range_min = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "band_range_max") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            band_range_max = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            col_skip_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_pattern") == 0)
    {
        if (__index < 16)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                col_skip_pattern[__index] = (BOOL)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    col_skip_pattern[__index] = (BOOL)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "downsampling_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            downsampling_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_bands_dependent_downsampling") == 0)
    {
        if (__index < num_bands_dependent_downsamplingCount)
        {
            __result = num_bands_dependent_downsampling[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "bandStrength") == 0)
    {
        __result = bandStrength.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatix_afd_scd_data_type::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, "sad_thr") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sad_thr = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sadr_thr") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sadr_thr = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sad_max_frame") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sad_max_frame = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyro") == 0)
    {
        __result = gyro.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

bool chromatix_afd_static_data_type::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, "thldLevel2Ratio") == 0)
    {
        ParameterUtils::DoubleToString((double)thldLevel2Ratio, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thldLevel3Ratio") == 0)
    {
        ParameterUtils::DoubleToString((double)thldLevel3Ratio, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thldLevel2Col") == 0)
    {
        ParameterUtils::DoubleToString((double)thldLevel2Col, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thldLevel3Col") == 0)
    {
        ParameterUtils::DoubleToString((double)thldLevel3Col, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thldEkL") == 0)
    {
        ParameterUtils::DoubleToString((double)thldEkL, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thldEkU") == 0)
    {
        ParameterUtils::DoubleToString((double)thldEkU, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thldCounterL3") == 0)
    {
        ParameterUtils::DoubleToString((double)thldCounterL3, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "thldCounterL2") == 0)
    {
        ParameterUtils::DoubleToString((double)thldCounterL2, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "LevelDepth") == 0)
    {
        ParameterUtils::DoubleToString((double)LevelDepth, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_step_size") == 0)
    {
        ParameterUtils::DoubleToString((double)static_step_size, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_down_size") == 0)
    {
        ParameterUtils::DoubleToString((double)static_down_size, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)col_skip_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_pattern") == 0)
    {
        if (__index < 16)
        {
            ParameterUtils::DoubleToString((double)col_skip_pattern[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 16; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)col_skip_pattern[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_k_step") == 0)
    {
        ParameterUtils::DoubleToString((double)static_k_step, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_slope_steep_thr") == 0)
    {
        ParameterUtils::DoubleToString((double)static_slope_steep_thr, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_slope_not_steep_thr") == 0)
    {
        ParameterUtils::DoubleToString((double)static_slope_not_steep_thr, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_level_slope_ratio") == 0)
    {
        ParameterUtils::DoubleToString((double)static_confidence_level_slope_ratio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_thr_h") == 0)
    {
        ParameterUtils::DoubleToString((double)static_confidence_thr_h, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_thr_l") == 0)
    {
        ParameterUtils::DoubleToString((double)static_confidence_thr_l, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_ratio_h") == 0)
    {
        ParameterUtils::DoubleToString((double)static_confidence_ratio_h, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_ratio_l") == 0)
    {
        ParameterUtils::DoubleToString((double)static_confidence_ratio_l, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_low_rowsum_thr") == 0)
    {
        ParameterUtils::DoubleToString((double)static_low_rowsum_thr, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "static_low_rowsum_comp") == 0)
    {
        ParameterUtils::DoubleToString((double)static_low_rowsum_comp, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "downsampling_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)downsampling_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_bands_dependent_downsampling") == 0)
    {
        if (__index < num_bands_dependent_downsamplingCount)
        {
            __result = num_bands_dependent_downsampling[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatix_afd_static_data_type::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, "thldLevel2Ratio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thldLevel2Ratio = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thldLevel3Ratio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thldLevel3Ratio = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thldLevel2Col") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thldLevel2Col = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thldLevel3Col") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thldLevel3Col = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thldEkL") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thldEkL = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thldEkU") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thldEkU = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thldCounterL3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thldCounterL3 = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "thldCounterL2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            thldCounterL2 = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "LevelDepth") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            LevelDepth = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_step_size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_step_size = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_down_size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_down_size = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            col_skip_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_pattern") == 0)
    {
        if (__index < 16)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                col_skip_pattern[__index] = (BOOL)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    col_skip_pattern[__index] = (BOOL)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_k_step") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_k_step = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_slope_steep_thr") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_slope_steep_thr = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_slope_not_steep_thr") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_slope_not_steep_thr = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_level_slope_ratio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_confidence_level_slope_ratio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_thr_h") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_confidence_thr_h = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_thr_l") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_confidence_thr_l = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_ratio_h") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_confidence_ratio_h = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_confidence_ratio_l") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_confidence_ratio_l = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_low_rowsum_thr") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_low_rowsum_thr = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "static_low_rowsum_comp") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            static_low_rowsum_comp = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "downsampling_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            downsampling_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_bands_dependent_downsampling") == 0)
    {
        if (__index < num_bands_dependent_downsamplingCount)
        {
            __result = num_bands_dependent_downsampling[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool afd_correlation_based_rolling_data_type::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, "confidence_trigger_data") == 0)
    {
        if (__index < confidence_trigger_dataCount)
        {
            __result = confidence_trigger_data[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidence_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)confidence_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "min_valid_cols") == 0)
    {
        ParameterUtils::DoubleToString((double)min_valid_cols, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)col_skip_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_pattern") == 0)
    {
        if (__index < 16)
        {
            ParameterUtils::DoubleToString((double)col_skip_pattern[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 16; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)col_skip_pattern[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "downsampling_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)downsampling_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_bands_dependent_downsampling") == 0)
    {
        if (__index < num_bands_dependent_downsamplingCount)
        {
            __result = num_bands_dependent_downsampling[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool afd_correlation_based_rolling_data_type::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, "confidence_trigger_data") == 0)
    {
        if (__index < confidence_trigger_dataCount)
        {
            __result = confidence_trigger_data[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidence_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confidence_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "min_valid_cols") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            min_valid_cols = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            col_skip_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_pattern") == 0)
    {
        if (__index < 16)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                col_skip_pattern[__index] = (BOOL)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    col_skip_pattern[__index] = (BOOL)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "downsampling_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            downsampling_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_bands_dependent_downsampling") == 0)
    {
        if (__index < num_bands_dependent_downsamplingCount)
        {
            __result = num_bands_dependent_downsampling[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

bool afd_correlation_based_static_data_type::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, "num_periods") == 0)
    {
        ParameterUtils::DoubleToString((double)num_periods, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "step_size") == 0)
    {
        ParameterUtils::DoubleToString((double)step_size, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "max_absolute_energy") == 0)
    {
        ParameterUtils::DoubleToString((double)max_absolute_energy, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "min_flat_segments") == 0)
    {
        ParameterUtils::DoubleToString((double)min_flat_segments, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "confidence_trigger_data") == 0)
    {
        if (__index < confidence_trigger_dataCount)
        {
            __result = confidence_trigger_data[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidence_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)confidence_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)col_skip_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_pattern") == 0)
    {
        if (__index < 16)
        {
            ParameterUtils::DoubleToString((double)col_skip_pattern[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 16; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)col_skip_pattern[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "downsampling_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)downsampling_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_bands_dependent_downsampling") == 0)
    {
        if (__index < num_bands_dependent_downsamplingCount)
        {
            __result = num_bands_dependent_downsampling[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool afd_correlation_based_static_data_type::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, "num_periods") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_periods = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "step_size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            step_size = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "max_absolute_energy") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            max_absolute_energy = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "min_flat_segments") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            min_flat_segments = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidence_trigger_data") == 0)
    {
        if (__index < confidence_trigger_dataCount)
        {
            __result = confidence_trigger_data[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "confidence_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            confidence_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            col_skip_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "col_skip_pattern") == 0)
    {
        if (__index < 16)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                col_skip_pattern[__index] = (BOOL)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    col_skip_pattern[__index] = (BOOL)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "downsampling_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            downsampling_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_bands_dependent_downsampling") == 0)
    {
        if (__index < num_bands_dependent_downsamplingCount)
        {
            __result = num_bands_dependent_downsampling[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatix_afd_short_exposure_monitor_type::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, "afd_rs_stats_exposure_type") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)afd_rs_stats_exposure_type, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "afd_bg_stats_exposure_type") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)afd_bg_stats_exposure_type, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "always_enable_short_exposure_monitor") == 0)
    {
        ParameterUtils::DoubleToString((double)always_enable_short_exposure_monitor, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enable_short_exposure_monitor_when_exposure_is_short") == 0)
    {
        ParameterUtils::DoubleToString((double)enable_short_exposure_monitor_when_exposure_is_short, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "afd_correlation_based_rolling") == 0)
    {
        __result = afd_correlation_based_rolling.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_correlation_based_static") == 0)
    {
        __result = afd_correlation_based_static.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "extension_param") == 0)
    {
        if (__index < extension_paramCount)
        {
            __result = extension_param[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool chromatix_afd_short_exposure_monitor_type::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, "afd_rs_stats_exposure_type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            afd_rs_stats_exposure_type = (afd_exposure_type)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "afd_bg_stats_exposure_type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            afd_bg_stats_exposure_type = (afd_exposure_type)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "always_enable_short_exposure_monitor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            always_enable_short_exposure_monitor = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enable_short_exposure_monitor_when_exposure_is_short") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable_short_exposure_monitor_when_exposure_is_short = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "afd_correlation_based_rolling") == 0)
    {
        __result = afd_correlation_based_rolling.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_correlation_based_static") == 0)
    {
        __result = afd_correlation_based_static.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "extension_param") == 0)
    {
        if (__index < extension_paramCount)
        {
            __result = extension_param[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatix_auto_flicker_detection_data_type::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, "use_correlation_based_rolling_detection") == 0)
    {
        ParameterUtils::DoubleToString((double)use_correlation_based_rolling_detection, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "use_correlation_based_static_detection") == 0)
    {
        ParameterUtils::DoubleToString((double)use_correlation_based_static_detection, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frame_ct_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)frame_ct_threshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frame_smooth_detection_thr") == 0)
    {
        ParameterUtils::DoubleToString((double)frame_smooth_detection_thr, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frame_smooth_ct_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)frame_smooth_ct_threshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_frames") == 0)
    {
        ParameterUtils::DoubleToString((double)num_frames, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frame_skip") == 0)
    {
        ParameterUtils::DoubleToString((double)frame_skip, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_rows") == 0)
    {
        ParameterUtils::DoubleToString((double)num_rows, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_cols") == 0)
    {
        ParameterUtils::DoubleToString((double)num_cols, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "switch_on_first_detection") == 0)
    {
        ParameterUtils::DoubleToString((double)switch_on_first_detection, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "max_attempts_for_second_detection") == 0)
    {
        ParameterUtils::DoubleToString((double)max_attempts_for_second_detection, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "AFD_continuous_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)AFD_continuous_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_frames_settle") == 0)
    {
        ParameterUtils::DoubleToString((double)num_frames_settle, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "start_antbanding_table") == 0)
    {
        ParameterUtils::DoubleToString((double)start_antbanding_table, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "max_exp_time_ms") == 0)
    {
        ParameterUtils::DoubleToString((double)max_exp_time_ms, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "AFD_always_on_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)AFD_always_on_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "AFD_static_band_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)AFD_static_band_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "af_status_check") == 0)
    {
        __result = af_status_check.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "frame_similarity_check_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)frame_similarity_check_enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "similarity_ratio_thresh") == 0)
    {
        ParameterUtils::DoubleToString((double)similarity_ratio_thresh, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "similar_frame_count_thresh") == 0)
    {
        ParameterUtils::DoubleToString((double)similar_frame_count_thresh, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enable_dark_sat_filtering") == 0)
    {
        ParameterUtils::DoubleToString((double)enable_dark_sat_filtering, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dark_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)dark_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "bright_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)bright_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dark_cnt_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)dark_cnt_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "bright_cnt_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)bright_cnt_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "afd_bright_light_trigger") == 0)
    {
        __result = afd_bright_light_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_low_light_trigger") == 0)
    {
        __result = afd_low_light_trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_rolling_bright") == 0)
    {
        __result = afd_rolling_bright.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_rolling_normal") == 0)
    {
        __result = afd_rolling_normal.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_rolling_lowlight") == 0)
    {
        __result = afd_rolling_lowlight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_static_bright") == 0)
    {
        __result = afd_static_bright.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_static_normal") == 0)
    {
        __result = afd_static_normal.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_static_lowlight") == 0)
    {
        __result = afd_static_lowlight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_correlation_based_rolling") == 0)
    {
        __result = afd_correlation_based_rolling.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_correlation_based_static") == 0)
    {
        __result = afd_correlation_based_static.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_scd_bright") == 0)
    {
        __result = afd_scd_bright.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_scd_normal") == 0)
    {
        __result = afd_scd_normal.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_scd_lowlight") == 0)
    {
        __result = afd_scd_lowlight.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_param_extension") == 0)
    {
        __result = afd_param_extension.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_rs_skip_parsing") == 0)
    {
        __result = afd_rs_skip_parsing.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "afd_short_exposure_monitor") == 0)
    {
        __result = afd_short_exposure_monitor.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "stats_window_config") == 0)
    {
        __result = stats_window_config.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatix_auto_flicker_detection_data_type::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, "use_correlation_based_rolling_detection") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            use_correlation_based_rolling_detection = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "use_correlation_based_static_detection") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            use_correlation_based_static_detection = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frame_ct_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frame_ct_threshold = (UINT64)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frame_smooth_detection_thr") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frame_smooth_detection_thr = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frame_smooth_ct_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frame_smooth_ct_threshold = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_frames") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_frames = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frame_skip") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frame_skip = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_rows") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_rows = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_cols") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_cols = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "switch_on_first_detection") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            switch_on_first_detection = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "max_attempts_for_second_detection") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            max_attempts_for_second_detection = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "AFD_continuous_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            AFD_continuous_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_frames_settle") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_frames_settle = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "start_antbanding_table") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            start_antbanding_table = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "max_exp_time_ms") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            max_exp_time_ms = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "AFD_always_on_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            AFD_always_on_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "AFD_static_band_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            AFD_static_band_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "af_status_check") == 0)
    {
        __result = af_status_check.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "frame_similarity_check_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frame_similarity_check_enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "similarity_ratio_thresh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            similarity_ratio_thresh = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "similar_frame_count_thresh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            similar_frame_count_thresh = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enable_dark_sat_filtering") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable_dark_sat_filtering = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dark_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dark_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "bright_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            bright_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dark_cnt_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dark_cnt_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "bright_cnt_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            bright_cnt_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "afd_bright_light_trigger") == 0)
    {
        __result = afd_bright_light_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_low_light_trigger") == 0)
    {
        __result = afd_low_light_trigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_rolling_bright") == 0)
    {
        __result = afd_rolling_bright.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_rolling_normal") == 0)
    {
        __result = afd_rolling_normal.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_rolling_lowlight") == 0)
    {
        __result = afd_rolling_lowlight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_static_bright") == 0)
    {
        __result = afd_static_bright.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_static_normal") == 0)
    {
        __result = afd_static_normal.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_static_lowlight") == 0)
    {
        __result = afd_static_lowlight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_correlation_based_rolling") == 0)
    {
        __result = afd_correlation_based_rolling.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_correlation_based_static") == 0)
    {
        __result = afd_correlation_based_static.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_scd_bright") == 0)
    {
        __result = afd_scd_bright.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_scd_normal") == 0)
    {
        __result = afd_scd_normal.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_scd_lowlight") == 0)
    {
        __result = afd_scd_lowlight.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_param_extension") == 0)
    {
        __result = afd_param_extension.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_rs_skip_parsing") == 0)
    {
        __result = afd_rs_skip_parsing.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "afd_short_exposure_monitor") == 0)
    {
        __result = afd_short_exposure_monitor.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "stats_window_config") == 0)
    {
        __result = stats_window_config.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

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

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

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

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

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


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatix_auto_flicker_detection_data_typeClass::chromatix_auto_flicker_detection_data_typeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(use_correlation_based_rolling_detection);
    PARAMETER_INITIALIZE(use_correlation_based_static_detection);
    PARAMETER_INITIALIZE(frame_ct_threshold);
    PARAMETER_INITIALIZE(frame_smooth_detection_thr);
    PARAMETER_INITIALIZE(frame_smooth_ct_threshold);
    PARAMETER_INITIALIZE(num_frames);
    PARAMETER_INITIALIZE(frame_skip);
    PARAMETER_INITIALIZE(num_rows);
    PARAMETER_INITIALIZE(num_cols);
    PARAMETER_INITIALIZE(switch_on_first_detection);
    PARAMETER_INITIALIZE(max_attempts_for_second_detection);
    PARAMETER_INITIALIZE(AFD_continuous_enable);
    PARAMETER_INITIALIZE(num_frames_settle);
    PARAMETER_INITIALIZE(start_antbanding_table);
    PARAMETER_INITIALIZE(max_exp_time_ms);
    PARAMETER_INITIALIZE(AFD_always_on_enable);
    PARAMETER_INITIALIZE(AFD_static_band_enable);
    PARAMETER_INITIALIZE(af_status_check);
    PARAMETER_INITIALIZE(frame_similarity_check_enable);
    PARAMETER_INITIALIZE(similarity_ratio_thresh);
    PARAMETER_INITIALIZE(similar_frame_count_thresh);
    PARAMETER_INITIALIZE(enable_dark_sat_filtering);
    PARAMETER_INITIALIZE(dark_threshold);
    PARAMETER_INITIALIZE(bright_threshold);
    PARAMETER_INITIALIZE(dark_cnt_threshold);
    PARAMETER_INITIALIZE(bright_cnt_threshold);
    PARAMETER_INITIALIZE(afd_bright_light_trigger);
    PARAMETER_INITIALIZE(afd_low_light_trigger);
    PARAMETER_INITIALIZE(afd_rolling_bright);
    PARAMETER_INITIALIZE(afd_rolling_normal);
    PARAMETER_INITIALIZE(afd_rolling_lowlight);
    PARAMETER_INITIALIZE(afd_static_bright);
    PARAMETER_INITIALIZE(afd_static_normal);
    PARAMETER_INITIALIZE(afd_static_lowlight);
    PARAMETER_INITIALIZE(afd_correlation_based_rolling);
    PARAMETER_INITIALIZE(afd_correlation_based_static);
    PARAMETER_INITIALIZE(afd_scd_bright);
    PARAMETER_INITIALIZE(afd_scd_normal);
    PARAMETER_INITIALIZE(afd_scd_lowlight);
    PARAMETER_INITIALIZE(afd_param_extension);
    PARAMETER_INITIALIZE(afd_rs_skip_parsing);
    PARAMETER_INITIALIZE(afd_short_exposure_monitor);
    PARAMETER_INITIALIZE(stats_window_config);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatix_auto_flicker_detection_data_typeClass::chromatix_auto_flicker_detection_data_typeClass(
    const CHAR* const name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(use_correlation_based_rolling_detection);
    PARAMETER_INITIALIZE(use_correlation_based_static_detection);
    PARAMETER_INITIALIZE(frame_ct_threshold);
    PARAMETER_INITIALIZE(frame_smooth_detection_thr);
    PARAMETER_INITIALIZE(frame_smooth_ct_threshold);
    PARAMETER_INITIALIZE(num_frames);
    PARAMETER_INITIALIZE(frame_skip);
    PARAMETER_INITIALIZE(num_rows);
    PARAMETER_INITIALIZE(num_cols);
    PARAMETER_INITIALIZE(switch_on_first_detection);
    PARAMETER_INITIALIZE(max_attempts_for_second_detection);
    PARAMETER_INITIALIZE(AFD_continuous_enable);
    PARAMETER_INITIALIZE(num_frames_settle);
    PARAMETER_INITIALIZE(start_antbanding_table);
    PARAMETER_INITIALIZE(max_exp_time_ms);
    PARAMETER_INITIALIZE(AFD_always_on_enable);
    PARAMETER_INITIALIZE(AFD_static_band_enable);
    PARAMETER_INITIALIZE(af_status_check);
    PARAMETER_INITIALIZE(frame_similarity_check_enable);
    PARAMETER_INITIALIZE(similarity_ratio_thresh);
    PARAMETER_INITIALIZE(similar_frame_count_thresh);
    PARAMETER_INITIALIZE(enable_dark_sat_filtering);
    PARAMETER_INITIALIZE(dark_threshold);
    PARAMETER_INITIALIZE(bright_threshold);
    PARAMETER_INITIALIZE(dark_cnt_threshold);
    PARAMETER_INITIALIZE(bright_cnt_threshold);
    PARAMETER_INITIALIZE(afd_bright_light_trigger);
    PARAMETER_INITIALIZE(afd_low_light_trigger);
    PARAMETER_INITIALIZE(afd_rolling_bright);
    PARAMETER_INITIALIZE(afd_rolling_normal);
    PARAMETER_INITIALIZE(afd_rolling_lowlight);
    PARAMETER_INITIALIZE(afd_static_bright);
    PARAMETER_INITIALIZE(afd_static_normal);
    PARAMETER_INITIALIZE(afd_static_lowlight);
    PARAMETER_INITIALIZE(afd_correlation_based_rolling);
    PARAMETER_INITIALIZE(afd_correlation_based_static);
    PARAMETER_INITIALIZE(afd_scd_bright);
    PARAMETER_INITIALIZE(afd_scd_normal);
    PARAMETER_INITIALIZE(afd_scd_lowlight);
    PARAMETER_INITIALIZE(afd_param_extension);
    PARAMETER_INITIALIZE(afd_rs_skip_parsing);
    PARAMETER_INITIALIZE(afd_short_exposure_monitor);
    PARAMETER_INITIALIZE(stats_window_config);
}

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

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

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

    PARAMETER_INITIALIZE(extension_param);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(start);
    PARAMETER_INITIALIZE(end);

    SYMBOL_TABLE_ENTRY_READ(entry, result, start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, end, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable_window_config);
    PARAMETER_INITIALIZE(make_skip_multiple_2);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable_window_config, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, make_skip_multiple_2, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable_rolling_strength);
    PARAMETER_INITIALIZE(strength_threshold);
    PARAMETER_INITIALIZE(sumAvgForPeakEnable);
    PARAMETER_INITIALIZE(coutNumForPeakSum);
    PARAMETER_INITIALIZE(fakePeakSumAvgThres);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable_rolling_strength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, strength_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, sumAvgForPeakEnable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, coutNumForPeakSum, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fakePeakSumAvgThres, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(gyroInfoAssistSCDEnable);
    PARAMETER_INITIALIZE(gyroInfoFilterLength);
    PARAMETER_INITIALIZE(movingThresholdForGyroInfo);

    SYMBOL_TABLE_ENTRY_READ(entry, result, gyroInfoAssistSCDEnable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyroInfoFilterLength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, movingThresholdForGyroInfo, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, triggerData, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(lux_index_start);
    PARAMETER_INITIALIZE(lux_index_end);

    SYMBOL_TABLE_ENTRY_READ(entry, result, lux_index_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, lux_index_end, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(num_bands_start);
    PARAMETER_INITIALIZE(num_bands_end);
    PARAMETER_INITIALIZE(downsampling_factor);

    SYMBOL_TABLE_ENTRY_READ(entry, result, num_bands_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, num_bands_end, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, downsampling_factor, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(af_status_select);
    PARAMETER_INITIALIZE(stable_lens_pos_threshold);
    PARAMETER_INITIALIZE(stable_lens_pos_frame_count);

    result = afdTuning::ReadEnum_af_status_select_type(entry, af_status_select, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, stable_lens_pos_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, stable_lens_pos_frame_count, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(std_threshold);
    PARAMETER_INITIALIZE(percent_threshold);
    PARAMETER_INITIALIZE(diff_threshold);
    PARAMETER_INITIALIZE(num_peaks_threshold);
    PARAMETER_INITIALIZE(num_flicker_threshold);
    PARAMETER_INITIALIZE(band_dist_comp);
    PARAMETER_INITIALIZE(band_range_min);
    PARAMETER_INITIALIZE(band_range_max);
    PARAMETER_INITIALIZE(col_skip_enable);
    PARAMETER_INITIALIZE(col_skip_pattern);
    PARAMETER_INITIALIZE(downsampling_enable);
    PARAMETER_INITIALIZE(num_bands_dependent_downsampling);
    PARAMETER_INITIALIZE(bandStrength);

    SYMBOL_TABLE_ENTRY_READ(entry, result, std_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, percent_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, diff_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, num_peaks_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, num_flicker_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, band_dist_comp, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, band_range_min, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, band_range_max, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, col_skip_enable, alignment)
    if (result)
    {
        result = entry->ReadArray(col_skip_pattern, 16, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, downsampling_enable, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(sad_thr);
    PARAMETER_INITIALIZE(sadr_thr);
    PARAMETER_INITIALIZE(sad_max_frame);
    PARAMETER_INITIALIZE(gyro);

    SYMBOL_TABLE_ENTRY_READ(entry, result, sad_thr, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, sadr_thr, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, sad_max_frame, alignment)
    if (result)
    {
        result = gyro.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(thldLevel2Ratio);
    PARAMETER_INITIALIZE(thldLevel3Ratio);
    PARAMETER_INITIALIZE(thldLevel2Col);
    PARAMETER_INITIALIZE(thldLevel3Col);
    PARAMETER_INITIALIZE(thldEkL);
    PARAMETER_INITIALIZE(thldEkU);
    PARAMETER_INITIALIZE(thldCounterL3);
    PARAMETER_INITIALIZE(thldCounterL2);
    PARAMETER_INITIALIZE(LevelDepth);
    PARAMETER_INITIALIZE(static_step_size);
    PARAMETER_INITIALIZE(static_down_size);
    PARAMETER_INITIALIZE(col_skip_enable);
    PARAMETER_INITIALIZE(col_skip_pattern);
    PARAMETER_INITIALIZE(static_k_step);
    PARAMETER_INITIALIZE(static_slope_steep_thr);
    PARAMETER_INITIALIZE(static_slope_not_steep_thr);
    PARAMETER_INITIALIZE(static_confidence_level_slope_ratio);
    PARAMETER_INITIALIZE(static_confidence_thr_h);
    PARAMETER_INITIALIZE(static_confidence_thr_l);
    PARAMETER_INITIALIZE(static_confidence_ratio_h);
    PARAMETER_INITIALIZE(static_confidence_ratio_l);
    PARAMETER_INITIALIZE(static_low_rowsum_thr);
    PARAMETER_INITIALIZE(static_low_rowsum_comp);
    PARAMETER_INITIALIZE(downsampling_enable);
    PARAMETER_INITIALIZE(num_bands_dependent_downsampling);

    SYMBOL_TABLE_ENTRY_READ(entry, result, thldLevel2Ratio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thldLevel3Ratio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thldLevel2Col, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thldLevel3Col, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thldEkL, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thldEkU, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thldCounterL3, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, thldCounterL2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, LevelDepth, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_step_size, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_down_size, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, col_skip_enable, alignment)
    if (result)
    {
        result = entry->ReadArray(col_skip_pattern, 16, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_k_step, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_slope_steep_thr, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_slope_not_steep_thr, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_confidence_level_slope_ratio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_confidence_thr_h, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_confidence_thr_l, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_confidence_ratio_h, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_confidence_ratio_l, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_low_rowsum_thr, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, static_low_rowsum_comp, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, downsampling_enable, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(confidence_trigger_data);
    PARAMETER_INITIALIZE(confidence_threshold);
    PARAMETER_INITIALIZE(min_valid_cols);
    PARAMETER_INITIALIZE(col_skip_enable);
    PARAMETER_INITIALIZE(col_skip_pattern);
    PARAMETER_INITIALIZE(downsampling_enable);
    PARAMETER_INITIALIZE(num_bands_dependent_downsampling);


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

            if (confidence_trigger_data == nullptr)
            {
                if (result && confidence_trigger_dataCount > 0)
                {
                    confidence_trigger_data = PARAMETER_NEW afdLUTLevel2Type[confidence_trigger_dataCount];
                    (void)pointerEntry->SetDupObject(confidence_trigger_data, confidence_trigger_dataCount, file, line);
                }
                if (!result || confidence_trigger_data == nullptr)
                {
                    if (confidence_trigger_dataCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate confidence_trigger_data\n");
                    }
                    confidence_trigger_dataCount = 0;
                }
                for (UINT32 i = 0; result && i < confidence_trigger_dataCount; i++)
                {
                    result = confidence_trigger_data[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (confidence_trigger_data == nullptr)
        {
            confidence_trigger_dataCount = 0;
        }
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, confidence_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, min_valid_cols, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, col_skip_enable, alignment)
    if (result)
    {
        result = entry->ReadArray(col_skip_pattern, 16, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, downsampling_enable, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(num_periods);
    PARAMETER_INITIALIZE(step_size);
    PARAMETER_INITIALIZE(max_absolute_energy);
    PARAMETER_INITIALIZE(min_flat_segments);
    PARAMETER_INITIALIZE(confidence_trigger_data);
    PARAMETER_INITIALIZE(confidence_threshold);
    PARAMETER_INITIALIZE(col_skip_enable);
    PARAMETER_INITIALIZE(col_skip_pattern);
    PARAMETER_INITIALIZE(downsampling_enable);
    PARAMETER_INITIALIZE(num_bands_dependent_downsampling);

    SYMBOL_TABLE_ENTRY_READ(entry, result, num_periods, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, step_size, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, max_absolute_energy, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, min_flat_segments, alignment)

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

            if (confidence_trigger_data == nullptr)
            {
                if (result && confidence_trigger_dataCount > 0)
                {
                    confidence_trigger_data = PARAMETER_NEW afdLUTLevel2Type[confidence_trigger_dataCount];
                    (void)pointerEntry->SetDupObject(confidence_trigger_data, confidence_trigger_dataCount, file, line);
                }
                if (!result || confidence_trigger_data == nullptr)
                {
                    if (confidence_trigger_dataCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate confidence_trigger_data\n");
                    }
                    confidence_trigger_dataCount = 0;
                }
                for (UINT32 i = 0; result && i < confidence_trigger_dataCount; i++)
                {
                    result = confidence_trigger_data[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (confidence_trigger_data == nullptr)
        {
            confidence_trigger_dataCount = 0;
        }
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, confidence_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, col_skip_enable, alignment)
    if (result)
    {
        result = entry->ReadArray(col_skip_pattern, 16, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, downsampling_enable, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(afd_rs_stats_exposure_type);
    PARAMETER_INITIALIZE(afd_bg_stats_exposure_type);
    PARAMETER_INITIALIZE(always_enable_short_exposure_monitor);
    PARAMETER_INITIALIZE(enable_short_exposure_monitor_when_exposure_is_short);
    PARAMETER_INITIALIZE(afd_correlation_based_rolling);
    PARAMETER_INITIALIZE(afd_correlation_based_static);
    PARAMETER_INITIALIZE(extension_param);

    result = afdTuning::ReadEnum_afd_exposure_type(entry, afd_rs_stats_exposure_type, alignment);
    if (result)
    {
        result = afdTuning::ReadEnum_afd_exposure_type(entry, afd_bg_stats_exposure_type, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, always_enable_short_exposure_monitor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enable_short_exposure_monitor_when_exposure_is_short, alignment)
    if (result)
    {
        result = afd_correlation_based_rolling.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_correlation_based_static.Load(entry, alignment);
    }

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(use_correlation_based_rolling_detection);
    PARAMETER_INITIALIZE(use_correlation_based_static_detection);
    PARAMETER_INITIALIZE(frame_ct_threshold);
    PARAMETER_INITIALIZE(frame_smooth_detection_thr);
    PARAMETER_INITIALIZE(frame_smooth_ct_threshold);
    PARAMETER_INITIALIZE(num_frames);
    PARAMETER_INITIALIZE(frame_skip);
    PARAMETER_INITIALIZE(num_rows);
    PARAMETER_INITIALIZE(num_cols);
    PARAMETER_INITIALIZE(switch_on_first_detection);
    PARAMETER_INITIALIZE(max_attempts_for_second_detection);
    PARAMETER_INITIALIZE(AFD_continuous_enable);
    PARAMETER_INITIALIZE(num_frames_settle);
    PARAMETER_INITIALIZE(start_antbanding_table);
    PARAMETER_INITIALIZE(max_exp_time_ms);
    PARAMETER_INITIALIZE(AFD_always_on_enable);
    PARAMETER_INITIALIZE(AFD_static_band_enable);
    PARAMETER_INITIALIZE(af_status_check);
    PARAMETER_INITIALIZE(frame_similarity_check_enable);
    PARAMETER_INITIALIZE(similarity_ratio_thresh);
    PARAMETER_INITIALIZE(similar_frame_count_thresh);
    PARAMETER_INITIALIZE(enable_dark_sat_filtering);
    PARAMETER_INITIALIZE(dark_threshold);
    PARAMETER_INITIALIZE(bright_threshold);
    PARAMETER_INITIALIZE(dark_cnt_threshold);
    PARAMETER_INITIALIZE(bright_cnt_threshold);
    PARAMETER_INITIALIZE(afd_bright_light_trigger);
    PARAMETER_INITIALIZE(afd_low_light_trigger);
    PARAMETER_INITIALIZE(afd_rolling_bright);
    PARAMETER_INITIALIZE(afd_rolling_normal);
    PARAMETER_INITIALIZE(afd_rolling_lowlight);
    PARAMETER_INITIALIZE(afd_static_bright);
    PARAMETER_INITIALIZE(afd_static_normal);
    PARAMETER_INITIALIZE(afd_static_lowlight);
    PARAMETER_INITIALIZE(afd_correlation_based_rolling);
    PARAMETER_INITIALIZE(afd_correlation_based_static);
    PARAMETER_INITIALIZE(afd_scd_bright);
    PARAMETER_INITIALIZE(afd_scd_normal);
    PARAMETER_INITIALIZE(afd_scd_lowlight);
    PARAMETER_INITIALIZE(afd_param_extension);
    PARAMETER_INITIALIZE(afd_rs_skip_parsing);
    PARAMETER_INITIALIZE(afd_short_exposure_monitor);
    PARAMETER_INITIALIZE(stats_window_config);

    result = module_version.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, use_correlation_based_rolling_detection, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, use_correlation_based_static_detection, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frame_ct_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frame_smooth_detection_thr, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frame_smooth_ct_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, num_frames, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frame_skip, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, num_rows, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, num_cols, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, switch_on_first_detection, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, max_attempts_for_second_detection, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, AFD_continuous_enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, num_frames_settle, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, start_antbanding_table, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, max_exp_time_ms, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, AFD_always_on_enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, AFD_static_band_enable, alignment)
    if (result)
    {
        result = af_status_check.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, frame_similarity_check_enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, similarity_ratio_thresh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, similar_frame_count_thresh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enable_dark_sat_filtering, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, dark_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, bright_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, dark_cnt_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, bright_cnt_threshold, alignment)
    if (result)
    {
        result = afd_bright_light_trigger.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_low_light_trigger.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_rolling_bright.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_rolling_normal.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_rolling_lowlight.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_static_bright.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_static_normal.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_static_lowlight.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_correlation_based_rolling.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_correlation_based_static.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_scd_bright.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_scd_normal.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_scd_lowlight.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_param_extension.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_rs_skip_parsing.Load(entry, alignment);
    }
    if (result)
    {
        result = afd_short_exposure_monitor.Load(entry, alignment);
    }
    if (result)
    {
        result = stats_window_config.Load(entry, alignment);
    }

    return result;
}

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

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

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

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

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatix_afd_short_exposure_monitor_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatix_afd_short_exposure_monitor_type::Unload(ParameterFileSymbolTable* const __table)
{
    afd_correlation_based_rolling.Unload(__table);
    afd_correlation_based_static.Unload(__table);
    for (UINT32 i = 0; i < extension_paramCount; i++)
    {
        extension_param[i].Unload(__table);
    }
    if (__table != nullptr && __table->ReleaseDupObject(extension_param))
    {
        PARAMETER_DELETE[] extension_param;
    }
    extension_param = nullptr;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatix_auto_flicker_detection_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatix_auto_flicker_detection_data_type::Unload(ParameterFileSymbolTable* const __table)
{
    afd_rolling_bright.Unload(__table);
    afd_rolling_normal.Unload(__table);
    afd_rolling_lowlight.Unload(__table);
    afd_static_bright.Unload(__table);
    afd_static_normal.Unload(__table);
    afd_static_lowlight.Unload(__table);
    afd_correlation_based_rolling.Unload(__table);
    afd_correlation_based_static.Unload(__table);
    afd_param_extension.Unload(__table);
    afd_rs_skip_parsing.Unload(__table);
    afd_short_exposure_monitor.Unload(__table);
}

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

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

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

    return (ParameterModule*)cls;
}

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

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

AFDTUNING_NAMESPACE_END
