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

#include "aecxmetering.h"
#include "parametersetmanager.h"

AECXMETERING_NAMESPACE_BEGIN

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

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

bool roiLumaFilterType::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, "roiLumaFilterRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)roiLumaFilterRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaThresTolerance") == 0)
    {
        ParameterUtils::DoubleToString((double)roiLumaThresTolerance, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaDeltaThres") == 0)
    {
        ParameterUtils::DoubleToString((double)roiLumaDeltaThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaDeltaStrength1") == 0)
    {
        ParameterUtils::DoubleToString((double)roiLumaDeltaStrength1, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaDeltaStrength2") == 0)
    {
        ParameterUtils::DoubleToString((double)roiLumaDeltaStrength2, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stableCntThre") == 0)
    {
        ParameterUtils::DoubleToString((double)stableCntThre, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool roiLumaFilterType::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, "roiLumaFilterRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            roiLumaFilterRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaThresTolerance") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            roiLumaThresTolerance = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaDeltaThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            roiLumaDeltaThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaDeltaStrength1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            roiLumaDeltaStrength1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaDeltaStrength2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            roiLumaDeltaStrength2 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stableCntThre") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stableCntThre = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "version") == 0)
    {
        ParameterUtils::DoubleToString((double)version, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dataStorage") == 0)
    {
        __result = dataStorage.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sceneDetection") == 0)
    {
        __result = sceneDetection.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaFilter") == 0)
    {
        __result = roiLumaFilter.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "adjRatioFilter") == 0)
    {
        __result = adjRatioFilter.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "aeLockTimerThre") == 0)
    {
        ParameterUtils::DoubleToString((double)aeLockTimerThre, __value, __size, 0);
        __result = true;
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "version") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            version = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dataStorage") == 0)
    {
        __result = dataStorage.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sceneDetection") == 0)
    {
        __result = sceneDetection.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "roiLumaFilter") == 0)
    {
        __result = roiLumaFilter.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "adjRatioFilter") == 0)
    {
        __result = adjRatioFilter.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "aeLockTimerThre") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aeLockTimerThre = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    // trigger
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("trigger", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "trigger") == 0)
    {
        __result = trigger.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 LuxTrigInterpTriggerSystemLevel1Type::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, "trigger") == 0)
    {
        __result = trigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "trigger2Data") == 0)
    {
        if (__index < trigger2DataCount)
        {
            __result = trigger2Data[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableLuxAdjustment") == 0)
    {
        ParameterUtils::DoubleToString((double)enableLuxAdjustment, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "referenceExposureTime") == 0)
    {
        ParameterUtils::DoubleToString((double)referenceExposureTime, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "trigger1DataBank") == 0)
    {
        __result = trigger1DataBank.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "trigger2DataBank") == 0)
    {
        __result = trigger2DataBank.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "trigger3DataBank") == 0)
    {
        __result = trigger3DataBank.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "trigger1Data") == 0)
    {
        if (__index < trigger1DataCount)
        {
            __result = trigger1Data[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableLuxAdjustment") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableLuxAdjustment = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "referenceExposureTime") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            referenceExposureTime = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "trigger1DataBank") == 0)
    {
        __result = trigger1DataBank.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "trigger2DataBank") == 0)
    {
        __result = trigger2DataBank.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "trigger3DataBank") == 0)
    {
        __result = trigger3DataBank.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "trigger1Data") == 0)
    {
        if (__index < trigger1DataCount)
        {
            __result = trigger1Data[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

bool AntibandingMeteringType::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, "antibandingVsADRC") == 0)
    {
        __result = antibandingVsADRC.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "antibandingVsLuma") == 0)
    {
        __result = antibandingVsLuma.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "bRunOnlyWhenFlickerDetected") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            bRunOnlyWhenFlickerDetected = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "bStikyFlagIsFlickerDetected") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            bStikyFlagIsFlickerDetected = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "FCGVsADRC") == 0)
    {
        __result = FCGVsADRC.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

bool EVSCConfigType::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, "bEVSCDetector") == 0)
    {
        ParameterUtils::DoubleToString((double)bEVSCDetector, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "EVSCHistorySize") == 0)
    {
        ParameterUtils::DoubleToString((double)EVSCHistorySize, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "lumaChangeTh") == 0)
    {
        ParameterUtils::DoubleToString((double)lumaChangeTh, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pgChangeTh") == 0)
    {
        ParameterUtils::DoubleToString((double)pgChangeTh, __value, __size);
        __result = true;
    }

    return __result;
}

bool EVSCConfigType::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, "bEVSCDetector") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            bEVSCDetector = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "EVSCHistorySize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            EVSCHistorySize = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lumaChangeTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            lumaChangeTh = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pgChangeTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pgChangeTh = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

bool EVROIConfigType::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, "ROIType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)ROIType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "handlingType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)handlingType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ROIDetectionType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)ROIDetectionType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ROIChangePercTh") == 0)
    {
        ParameterUtils::DoubleToString((double)ROIChangePercTh, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minROIPercTh") == 0)
    {
        ParameterUtils::DoubleToString((double)minROIPercTh, __value, __size);
        __result = true;
    }

    return __result;
}

bool EVROIConfigType::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, "ROIType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROIType = (EVROIType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "handlingType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            handlingType = (EVROIHandlingType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROIDetectionType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROIDetectionType = (EVROIDetectionType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROIChangePercTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROIChangePercTh = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minROIPercTh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minROIPercTh = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        ParameterUtils::DoubleToString((double)enable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "SCDName") == 0)
    {
        PARAMETER_STRCPY(__value, __size, SCDName);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "scdDelayCount") == 0)
    {
        ParameterUtils::DoubleToString((double)scdDelayCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "EVROIConfig") == 0)
    {
        if (__index < EVROIConfigCount)
        {
            __result = EVROIConfig[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "EVSCConfig") == 0)
    {
        __result = EVSCConfig.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "EVPredConvConfig") == 0)
    {
        if (__index < EVPredConvConfigCount)
        {
            __result = EVPredConvConfig[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "SCDName") == 0)
    {
        // Cannot modify strings, risk of memory leaks or corruption
    }
    else if (PARAMETER_STRCMP(__name, "scdDelayCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            scdDelayCount = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "EVROIConfig") == 0)
    {
        if (__index < EVROIConfigCount)
        {
            __result = EVROIConfig[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "EVSCConfig") == 0)
    {
        __result = EVSCConfig.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "EVPredConvConfig") == 0)
    {
        if (__index < EVPredConvConfigCount)
        {
            __result = EVPredConvConfig[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

bool LuxIndexOperationType::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, "filteringFactor") == 0)
    {
        ParameterUtils::DoubleToString((double)filteringFactor, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableCompensation") == 0)
    {
        ParameterUtils::DoubleToString((double)enableCompensation, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "refExposureForLuxIndexZero") == 0)
    {
        ParameterUtils::DoubleToString((double)refExposureForLuxIndexZero, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enablePositiveEVCompensation") == 0)
    {
        ParameterUtils::DoubleToString((double)enablePositiveEVCompensation, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableNegativeEVCompensation") == 0)
    {
        ParameterUtils::DoubleToString((double)enableNegativeEVCompensation, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableEVLuxIndexLock") == 0)
    {
        ParameterUtils::DoubleToString((double)enableEVLuxIndexLock, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool LuxIndexOperationType::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, "filteringFactor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            filteringFactor = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableCompensation") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableCompensation = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "refExposureForLuxIndexZero") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            refExposureForLuxIndexZero = (UINT64)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enablePositiveEVCompensation") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enablePositiveEVCompensation = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableNegativeEVCompensation") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableNegativeEVCompensation = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableEVLuxIndexLock") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableEVLuxIndexLock = (BOOL)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "moduleID") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)moduleID, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "luxIndexOperation") == 0)
    {
        __result = luxIndexOperation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "dynamicMtrLockEV") == 0)
    {
        __result = dynamicMtrLockEV.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "trackerStatsROIProcess") == 0)
    {
        __result = trackerStatsROIProcess.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "antibandingMetering") == 0)
    {
        __result = antibandingMetering.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "aflowlumaalert") == 0)
    {
        __result = aflowlumaalert.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "moduleID") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            moduleID = (aecxglobalelements::AECXModuleIDType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "luxIndexOperation") == 0)
    {
        __result = luxIndexOperation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "dynamicMtrLockEV") == 0)
    {
        __result = dynamicMtrLockEV.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "trackerStatsROIProcess") == 0)
    {
        __result = trackerStatsROIProcess.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "antibandingMetering") == 0)
    {
        __result = antibandingMetering.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "aflowlumaalert") == 0)
    {
        __result = aflowlumaalert.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool AECXMeteringType::trackerStatsROIProcessStruct::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, "statsROIProcessEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            statsROIProcessEnable = (statsglobalelements::glbEnableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "statsROIPriority") == 0)
    {
        __result = statsROIPriority.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "statsROIStable") == 0)
    {
        __result = statsROIStable.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

    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_EVROIDetectionType(
    ParameterFileSymbolTableEntry* const entry,
    EVROIDetectionType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(EVROIDetectionType::ROICoordinates):
            enumValue = EVROIDetectionType::ROICoordinates;
            result    = true;
            break;
        case static_cast<UINT32>(EVROIDetectionType::ROIDominantId):
            enumValue = EVROIDetectionType::ROIDominantId;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to EVROIDetectionType", 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_EVROIHandlingType(
    ParameterFileSymbolTableEntry* const entry,
    EVROIHandlingType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(EVROIHandlingType::FreeFlow):
            enumValue = EVROIHandlingType::FreeFlow;
            result    = true;
            break;
        case static_cast<UINT32>(EVROIHandlingType::PredConv):
            enumValue = EVROIHandlingType::PredConv;
            result    = true;
            break;
        case static_cast<UINT32>(EVROIHandlingType::Ignore):
            enumValue = EVROIHandlingType::Ignore;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to EVROIHandlingType", 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_EVROIType(
    ParameterFileSymbolTableEntry* const entry,
    EVROIType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

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


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AECXMeteringTypeClass::AECXMeteringTypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(moduleID);
    PARAMETER_INITIALIZE(luxIndexOperation);
    PARAMETER_INITIALIZE(dynamicMtrLockEV);
    PARAMETER_INITIALIZE(trackerStatsROIProcess);
    PARAMETER_INITIALIZE(antibandingMetering);
    PARAMETER_INITIALIZE(aflowlumaalert);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AECXMeteringTypeClass::AECXMeteringTypeClass(
    const CHAR* const name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(moduleID);
    PARAMETER_INITIALIZE(luxIndexOperation);
    PARAMETER_INITIALIZE(dynamicMtrLockEV);
    PARAMETER_INITIALIZE(trackerStatsROIProcess);
    PARAMETER_INITIALIZE(antibandingMetering);
    PARAMETER_INITIALIZE(aflowlumaalert);
}

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

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

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

    PARAMETER_INITIALIZE(adjRatioTolerance);
    PARAMETER_INITIALIZE(adjRatioStrength);
    PARAMETER_INITIALIZE(maxAdjRatio);
    PARAMETER_INITIALIZE(filterSize);

    SYMBOL_TABLE_ENTRY_READ(entry, result, adjRatioTolerance, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, adjRatioStrength, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxAdjRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, filterSize, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(roiLumaFilterRatio);
    PARAMETER_INITIALIZE(roiLumaThresTolerance);
    PARAMETER_INITIALIZE(roiLumaDeltaThres);
    PARAMETER_INITIALIZE(roiLumaDeltaStrength1);
    PARAMETER_INITIALIZE(roiLumaDeltaStrength2);
    PARAMETER_INITIALIZE(stableCntThre);

    SYMBOL_TABLE_ENTRY_READ(entry, result, roiLumaFilterRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, roiLumaThresTolerance, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, roiLumaDeltaThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, roiLumaDeltaStrength1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, roiLumaDeltaStrength2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, stableCntThre, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(input);
    PARAMETER_INITIALIZE(threshold);
    PARAMETER_INITIALIZE(maxTimerCount);

    result = input.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxTimerCount, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(input);
    PARAMETER_INITIALIZE(threshold);

    result = input.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, threshold, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(motionBased);
    PARAMETER_INITIALIZE(drcBased);

    result = motionBased.Load(entry, alignment);
    if (result)
    {
        result = drcBased.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(AFLumaAdjRatioSAData);
    PARAMETER_INITIALIZE(AFLumaAlertEventData);
    PARAMETER_INITIALIZE(AFROITypeData);

    result = AFLumaAdjRatioSAData.Load(entry, alignment);
    if (result)
    {
        result = AFLumaAlertEventData.Load(entry, alignment);
    }
    if (result)
    {
        result = AFROITypeData.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(version);
    PARAMETER_INITIALIZE(dataStorage);
    PARAMETER_INITIALIZE(sceneDetection);
    PARAMETER_INITIALIZE(roiLumaFilter);
    PARAMETER_INITIALIZE(adjRatioFilter);
    PARAMETER_INITIALIZE(aeLockTimerThre);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, version, alignment)
    if (result)
    {
        result = dataStorage.Load(entry, alignment);
    }
    if (result)
    {
        result = sceneDetection.Load(entry, alignment);
    }
    if (result)
    {
        result = roiLumaFilter.Load(entry, alignment);
    }
    if (result)
    {
        result = adjRatioFilter.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, aeLockTimerThre, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(luxNodeStart);
    PARAMETER_INITIALIZE(luxNodeEnd);
    PARAMETER_INITIALIZE(luxNodeLowerBound);

    SYMBOL_TABLE_ENTRY_READ(entry, result, luxNodeStart, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, luxNodeEnd, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, luxNodeLowerBound, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(trigger);
    PARAMETER_INITIALIZE(triggerData);

    result = trigger.Load(entry, alignment);
    if (result)
    {
        result = triggerData.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(trigger);
    PARAMETER_INITIALIZE(triggerData);

    result = trigger.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 = (LuxTrigInterpTriggerSystemLevel3Type*)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 LuxTrigInterpTriggerSystemLevel3Type[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 LuxTrigInterpTriggerSystemLevel1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool LuxTrigInterpTriggerSystemLevel1Type::Load(
    ParameterFileSymbolTableEntry* const entry,
    BYTE const alignment)
{
    bool result = true;

    PARAMETER_INITIALIZE(trigger);
    PARAMETER_INITIALIZE(trigger2Data);

    result = trigger.Load(entry, alignment);

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(enableLuxAdjustment);
    PARAMETER_INITIALIZE(referenceExposureTime);
    PARAMETER_INITIALIZE(trigger1DataBank);
    PARAMETER_INITIALIZE(trigger2DataBank);
    PARAMETER_INITIALIZE(trigger3DataBank);
    PARAMETER_INITIALIZE(trigger1Data);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableLuxAdjustment, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, referenceExposureTime, alignment)
    if (result)
    {
        result = trigger1DataBank.Load(entry, alignment);
    }
    if (result)
    {
        result = trigger2DataBank.Load(entry, alignment);
    }
    if (result)
    {
        result = trigger3DataBank.Load(entry, alignment);
    }

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enableAntibandingPrioOverLuma);
    PARAMETER_INITIALIZE(clampThresholdAsFactorOfMinExposure);
    PARAMETER_INITIALIZE(exitThresholdAsFactorOfMinExposure);
    PARAMETER_INITIALIZE(luxTrigInterp);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableAntibandingPrioOverLuma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, clampThresholdAsFactorOfMinExposure, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, exitThresholdAsFactorOfMinExposure, alignment)
    if (result)
    {
        result = luxTrigInterp.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableAntibandingPrioOverADRC);
    PARAMETER_INITIALIZE(exitThresholdAsFactorOfMinExposure);
    PARAMETER_INITIALIZE(luxTrigInterp);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableAntibandingPrioOverADRC, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, exitThresholdAsFactorOfMinExposure, alignment)
    if (result)
    {
        result = luxTrigInterp.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(antibandingVsADRC);
    PARAMETER_INITIALIZE(antibandingVsLuma);
    PARAMETER_INITIALIZE(bRunOnlyWhenFlickerDetected);
    PARAMETER_INITIALIZE(bStikyFlagIsFlickerDetected);
    PARAMETER_INITIALIZE(FCGVsADRC);

    result = antibandingVsADRC.Load(entry, alignment);
    if (result)
    {
        result = antibandingVsLuma.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, bRunOnlyWhenFlickerDetected, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, bStikyFlagIsFlickerDetected, alignment)
    if (result)
    {
        result = FCGVsADRC.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(bStepConvEnable);
    PARAMETER_INITIALIZE(convStepSizeEI);

    SYMBOL_TABLE_ENTRY_READ(entry, result, bStepConvEnable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, convStepSizeEI, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(bEVSCDetector);
    PARAMETER_INITIALIZE(EVSCHistorySize);
    PARAMETER_INITIALIZE(lumaChangeTh);
    PARAMETER_INITIALIZE(pgChangeTh);

    SYMBOL_TABLE_ENTRY_READ(entry, result, bEVSCDetector, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, EVSCHistorySize, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, lumaChangeTh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pgChangeTh, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(ROIType);
    PARAMETER_INITIALIZE(handlingType);
    PARAMETER_INITIALIZE(ROIDetectionType);
    PARAMETER_INITIALIZE(ROIChangePercTh);
    PARAMETER_INITIALIZE(minROIPercTh);

    result = aecxmetering::ReadEnum_EVROIType(entry, ROIType, alignment);
    if (result)
    {
        result = aecxmetering::ReadEnum_EVROIHandlingType(entry, handlingType, alignment);
    }
    if (result)
    {
        result = aecxmetering::ReadEnum_EVROIDetectionType(entry, ROIDetectionType, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, ROIChangePercTh, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minROIPercTh, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(SCDName);
    PARAMETER_INITIALIZE(scdDelayCount);
    PARAMETER_INITIALIZE(EVROIConfig);
    PARAMETER_INITIALIZE(EVSCConfig);
    PARAMETER_INITIALIZE(EVPredConvConfig);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)

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

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

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(filteringFactor);
    PARAMETER_INITIALIZE(enableCompensation);
    PARAMETER_INITIALIZE(refExposureForLuxIndexZero);
    PARAMETER_INITIALIZE(enablePositiveEVCompensation);
    PARAMETER_INITIALIZE(enableNegativeEVCompensation);
    PARAMETER_INITIALIZE(enableEVLuxIndexLock);

    SYMBOL_TABLE_ENTRY_READ(entry, result, filteringFactor, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableCompensation, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, refExposureForLuxIndexZero, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enablePositiveEVCompensation, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableNegativeEVCompensation, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableEVLuxIndexLock, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(moduleID);
    PARAMETER_INITIALIZE(luxIndexOperation);
    PARAMETER_INITIALIZE(dynamicMtrLockEV);
    PARAMETER_INITIALIZE(trackerStatsROIProcess);
    PARAMETER_INITIALIZE(antibandingMetering);
    PARAMETER_INITIALIZE(aflowlumaalert);

    result = module_version.Load(entry, alignment);
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = aecxglobalelements::ReadEnum_AECXModuleIDType(entry, moduleID, alignment);
    }
    if (result)
    {
        result = luxIndexOperation.Load(entry, alignment);
    }
    if (result)
    {
        result = dynamicMtrLockEV.Load(entry, alignment);
    }
    if (result)
    {
        result = trackerStatsROIProcess.Load(entry, alignment);
    }
    if (result)
    {
        result = antibandingMetering.Load(entry, alignment);
    }
    if (result)
    {
        result = aflowlumaalert.Load(entry, alignment);
    }

    return result;
}

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(revision);


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

    return result;
}

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

    PARAMETER_INITIALIZE(statsROIProcessEnable);
    PARAMETER_INITIALIZE(statsROIPriority);
    PARAMETER_INITIALIZE(statsROIStable);

    SYMBOL_TABLE_ENTRY_READ(entry, result, statsROIProcessEnable, alignment)
    if (result)
    {
        result = statsROIPriority.Load(entry, alignment);
    }
    if (result)
    {
        result = statsROIStable.Load(entry, alignment);
    }

    return result;
}

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AntibandingPrioOverLumaType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AntibandingPrioOverLumaType::Unload(ParameterFileSymbolTable* const __table)
{
    luxTrigInterp.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AntibandingPrioOverADRCType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AntibandingPrioOverADRCType::Unload(ParameterFileSymbolTable* const __table)
{
    luxTrigInterp.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AntibandingMeteringType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AntibandingMeteringType::Unload(ParameterFileSymbolTable* const __table)
{
    antibandingVsADRC.Unload(__table);
    antibandingVsLuma.Unload(__table);
    FCGVsADRC.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload AECXMeteringType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECXMeteringType::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    dynamicMtrLockEV.Unload(__table);
    trackerStatsROIProcess.Unload(__table);
    antibandingMetering.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload trackerStatsROIProcessStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECXMeteringType::trackerStatsROIProcessStruct::Unload(ParameterFileSymbolTable* const __table)
{
    statsROIPriority.Unload(__table);
    statsROIStable.Unload(__table);
}

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

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

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

    return (ParameterModule*)cls;
}

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

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

AECXMETERING_NAMESPACE_END
