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

#include "aecglobalelements.h"
#include "parametersetmanager.h"

AECGLOBALELEMENTS_NAMESPACE_BEGIN

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "zoneTrigger") == 0)
    {
        __result = zoneTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zoneData") == 0)
    {
        __result = zoneData.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "zoneTrigger") == 0)
    {
        __result = zoneTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zoneData") == 0)
    {
        __result = zoneData.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "zoneTrigger") == 0)
    {
        __result = zoneTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zoneData") == 0)
    {
        __result = zoneData.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "zoneTrigger") == 0)
    {
        __result = zoneTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zoneData") == 0)
    {
        __result = zoneData.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "zoneTrigger") == 0)
    {
        __result = zoneTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zoneData") == 0)
    {
        __result = zoneData.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "zoneTrigger") == 0)
    {
        __result = zoneTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zoneData") == 0)
    {
        __result = zoneData.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

bool AECValueMonitorType::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, "detectionType") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)detectionType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "absoluteModeCfg") == 0)
    {
        __result = absoluteModeCfg.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileLow") == 0)
    {
        __result = sensProfileLow.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileMed") == 0)
    {
        __result = sensProfileMed.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileHigh") == 0)
    {
        __result = sensProfileHigh.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool AECValueMonitorType::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, "detectionType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            detectionType = (AECDetectorTypeEnum)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "absoluteModeCfg") == 0)
    {
        __result = absoluteModeCfg.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileLow") == 0)
    {
        __result = sensProfileLow.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileMed") == 0)
    {
        __result = sensProfileMed.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "sensProfileHigh") == 0)
    {
        __result = sensProfileHigh.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

bool HistTargetAdjustParamType::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, "minTargetAdjRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)minTargetAdjRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxTargetAdjRatio") == 0)
    {
        ParameterUtils::DoubleToString((double)maxTargetAdjRatio, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "darkRefLow") == 0)
    {
        ParameterUtils::DoubleToString((double)darkRefLow, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "satRefHigh") == 0)
    {
        ParameterUtils::DoubleToString((double)satRefHigh, __value, __size);
        __result = true;
    }

    return __result;
}

bool HistTargetAdjustParamType::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, "minTargetAdjRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minTargetAdjRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxTargetAdjRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxTargetAdjRatio = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "darkRefLow") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            darkRefLow = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "satRefHigh") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            satRefHigh = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "zoneTrigger") == 0)
    {
        __result = zoneTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "zoneData") == 0)
    {
        __result = zoneData.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "zoneTrigger") == 0)
    {
        __result = zoneTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "zoneData") == 0)
    {
        __result = zoneData.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

bool RapidConvType::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, "firstFrameBias") == 0)
    {
        __result = firstFrameBias.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "startExpIndex") == 0)
    {
        ParameterUtils::DoubleToString((double)startExpIndex, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tolMultUnitStepSize") == 0)
    {
        ParameterUtils::DoubleToString((double)tolMultUnitStepSize, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameSkipInit") == 0)
    {
        ParameterUtils::DoubleToString((double)frameSkipInit, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameSkip") == 0)
    {
        ParameterUtils::DoubleToString((double)frameSkip, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "minSettledCount") == 0)
    {
        ParameterUtils::DoubleToString((double)minSettledCount, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "maxFrameConvTimeOut") == 0)
    {
        ParameterUtils::DoubleToString((double)maxFrameConvTimeOut, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool RapidConvType::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, "firstFrameBias") == 0)
    {
        __result = firstFrameBias.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "startExpIndex") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            startExpIndex = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tolMultUnitStepSize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            tolMultUnitStepSize = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameSkipInit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameSkipInit = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameSkip") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameSkip = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "minSettledCount") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            minSettledCount = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "maxFrameConvTimeOut") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            maxFrameConvTimeOut = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            type = (AECSwitchCounterEnumType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "customInteger") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            customInteger = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

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

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

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

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AECBayerGridSubsmplType::Off):
            enumValue = AECBayerGridSubsmplType::Off;
            result    = true;
            break;
        case static_cast<UINT32>(AECBayerGridSubsmplType::SW2):
            enumValue = AECBayerGridSubsmplType::SW2;
            result    = true;
            break;
        case static_cast<UINT32>(AECBayerGridSubsmplType::SW4):
            enumValue = AECBayerGridSubsmplType::SW4;
            result    = true;
            break;
        case static_cast<UINT32>(AECBayerGridSubsmplType::Max):
            enumValue = AECBayerGridSubsmplType::Max;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AECBayerGridSubsmplType", 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_AECColorChannelType(
    ParameterFileSymbolTableEntry* const entry,
    AECColorChannelType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AECColorChannelType::AECColorChannelR):
            enumValue = AECColorChannelType::AECColorChannelR;
            result    = true;
            break;
        case static_cast<UINT32>(AECColorChannelType::AECColorChannelG):
            enumValue = AECColorChannelType::AECColorChannelG;
            result    = true;
            break;
        case static_cast<UINT32>(AECColorChannelType::AECColorChannelB):
            enumValue = AECColorChannelType::AECColorChannelB;
            result    = true;
            break;
        case static_cast<UINT32>(AECColorChannelType::AECColorChannelMax):
            enumValue = AECColorChannelType::AECColorChannelMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AECColorChannelType", 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_AECConvAlgoType(
    ParameterFileSymbolTableEntry* const entry,
    AECConvAlgoType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

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

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

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

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

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

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

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelR):
            enumValue = AECStatsHistogramChannelType::ChannelR;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelGr):
            enumValue = AECStatsHistogramChannelType::ChannelGr;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelGb):
            enumValue = AECStatsHistogramChannelType::ChannelGb;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelG):
            enumValue = AECStatsHistogramChannelType::ChannelG;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelB):
            enumValue = AECStatsHistogramChannelType::ChannelB;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelY):
            enumValue = AECStatsHistogramChannelType::ChannelY;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelCb):
            enumValue = AECStatsHistogramChannelType::ChannelCb;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelCr):
            enumValue = AECStatsHistogramChannelType::ChannelCr;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelRGrB):
            enumValue = AECStatsHistogramChannelType::ChannelRGrB;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsHistogramChannelType::ChannelRGbB):
            enumValue = AECStatsHistogramChannelType::ChannelRGbB;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AECStatsHistogramChannelType", 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_AECStatsSiteSelection(
    ParameterFileSymbolTableEntry* const entry,
    AECStatsSiteSelection& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AECStatsSiteSelection::BeforeHDRFusion):
            enumValue = AECStatsSiteSelection::BeforeHDRFusion;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsSiteSelection::BeforeDemosaic):
            enumValue = AECStatsSiteSelection::BeforeDemosaic;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsSiteSelection::BeforeGammaLUT):
            enumValue = AECStatsSiteSelection::BeforeGammaLUT;
            result    = true;
            break;
        case static_cast<UINT32>(AECStatsSiteSelection::AfterGammaLUT):
            enumValue = AECStatsSiteSelection::AfterGammaLUT;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AECStatsSiteSelection", 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_AECStatsPixelExpSelect(
    ParameterFileSymbolTableEntry* const entry,
    AECStatsPixelExpSelect& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

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

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

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(HistogramTargetEVMethodType::Legacy):
            enumValue = HistogramTargetEVMethodType::Legacy;
            result    = true;
            break;
        case static_cast<UINT32>(HistogramTargetEVMethodType::Compensated):
            enumValue = HistogramTargetEVMethodType::Compensated;
            result    = true;
            break;
        case static_cast<UINT32>(HistogramTargetEVMethodType::Freeze):
            enumValue = HistogramTargetEVMethodType::Freeze;
            result    = true;
            break;
        case static_cast<UINT32>(HistogramTargetEVMethodType::Advanced1):
            enumValue = HistogramTargetEVMethodType::Advanced1;
            result    = true;
            break;
        case static_cast<UINT32>(HistogramTargetEVMethodType::Advanced2):
            enumValue = HistogramTargetEVMethodType::Advanced2;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to HistogramTargetEVMethodType", 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_AECMtrAndExpoConfigType(
    ParameterFileSymbolTableEntry* const entry,
    AECMtrAndExpoConfigType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AECMtrAndExpoConfigType::MtrIndepExpIndep):
            enumValue = AECMtrAndExpoConfigType::MtrIndepExpIndep;
            result    = true;
            break;
        case static_cast<UINT32>(AECMtrAndExpoConfigType::MtrIndepExpFollow):
            enumValue = AECMtrAndExpoConfigType::MtrIndepExpFollow;
            result    = true;
            break;
        case static_cast<UINT32>(AECMtrAndExpoConfigType::MtrDisabledExpFollow):
            enumValue = AECMtrAndExpoConfigType::MtrDisabledExpFollow;
            result    = true;
            break;
        case static_cast<UINT32>(AECMtrAndExpoConfigType::MtrMixExpIndep):
            enumValue = AECMtrAndExpoConfigType::MtrMixExpIndep;
            result    = true;
            break;
        case static_cast<UINT32>(AECMtrAndExpoConfigType::MtrIndepExpDynamic):
            enumValue = AECMtrAndExpoConfigType::MtrIndepExpDynamic;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AECMtrAndExpoConfigType", 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_AECDualCamSlaveLuxType(
    ParameterFileSymbolTableEntry* const entry,
    AECDualCamSlaveLuxType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

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

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

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AECDepthLUTType::DepthLUTDistance):
            enumValue = AECDepthLUTType::DepthLUTDistance;
            result    = true;
            break;
        case static_cast<UINT32>(AECDepthLUTType::DepthLUTDepth):
            enumValue = AECDepthLUTType::DepthLUTDepth;
            result    = true;
            break;
        case static_cast<UINT32>(AECDepthLUTType::DepthLUTConfidence):
            enumValue = AECDepthLUTType::DepthLUTConfidence;
            result    = true;
            break;
        case static_cast<UINT32>(AECDepthLUTType::DepthLUTReserved1):
            enumValue = AECDepthLUTType::DepthLUTReserved1;
            result    = true;
            break;
        case static_cast<UINT32>(AECDepthLUTType::DepthLUTReserved2):
            enumValue = AECDepthLUTType::DepthLUTReserved2;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AECDepthLUTType", 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_AECSwitchCounterEnumType(
    ParameterFileSymbolTableEntry* const entry,
    AECSwitchCounterEnumType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AECSwitchCounterEnumType::SwitchCounterSystemDelay):
            enumValue = AECSwitchCounterEnumType::SwitchCounterSystemDelay;
            result    = true;
            break;
        case static_cast<UINT32>(AECSwitchCounterEnumType::SwitchCounterDisable):
            enumValue = AECSwitchCounterEnumType::SwitchCounterDisable;
            result    = true;
            break;
        case static_cast<UINT32>(AECSwitchCounterEnumType::SwitchCounterCustomInteger):
            enumValue = AECSwitchCounterEnumType::SwitchCounterCustomInteger;
            result    = true;
            break;
        case static_cast<UINT32>(AECSwitchCounterEnumType::SwitchCounterAdvanced1):
            enumValue = AECSwitchCounterEnumType::SwitchCounterAdvanced1;
            result    = true;
            break;
        case static_cast<UINT32>(AECSwitchCounterEnumType::SwitchCounterAdvanced2):
            enumValue = AECSwitchCounterEnumType::SwitchCounterAdvanced2;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AECSwitchCounterEnumType", 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_AECGyroExpCtrlTriggerDataType(
    ParameterFileSymbolTableEntry* const entry,
    AECGyroExpCtrlTriggerDataType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

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

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

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

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

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



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

    PARAMETER_INITIALIZE(lumaTarget);

    SYMBOL_TABLE_ENTRY_READ(entry, result, lumaTarget, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(start);
    PARAMETER_INITIALIZE(end);

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

    return result;
}

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

    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

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

    return result;
}

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

    PARAMETER_INITIALIZE(luxLumaTargetZone);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(start);
    PARAMETER_INITIALIZE(end);

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

    return result;
}

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

    PARAMETER_INITIALIZE(LuxFaceWeight);

    result = LuxFaceWeight.Load(entry, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

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

    return result;
}

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

    PARAMETER_INITIALIZE(LuxFaceWeightZone);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(LuxTrackerWeight);

    result = LuxTrackerWeight.Load(entry, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

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

    return result;
}

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

    PARAMETER_INITIALIZE(LuxTrackerWeightZone);


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

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

    return result;
}

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(numOfSamples);

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(numOfSamples);

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

    return result;
}

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(baseline);

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

    return result;
}

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

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

    result = aecglobalelements::ReadEnum_AECDetectorTypeEnum(entry, detectionType, alignment);
    if (result)
    {
        result = absoluteModeCfg.Load(entry, alignment);
    }
    if (result)
    {
        result = sensProfileLow.Load(entry, alignment);
    }
    if (result)
    {
        result = sensProfileMed.Load(entry, alignment);
    }
    if (result)
    {
        result = sensProfileHigh.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(minTargetAdjRatio);
    PARAMETER_INITIALIZE(maxTargetAdjRatio);
    PARAMETER_INITIALIZE(darkRefLow);
    PARAMETER_INITIALIZE(satRefHigh);

    SYMBOL_TABLE_ENTRY_READ(entry, result, minTargetAdjRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxTargetAdjRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, darkRefLow, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, satRefHigh, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(darkLumaRatioRange);
    PARAMETER_INITIALIZE(darkROIAdjustParams);
    PARAMETER_INITIALIZE(brightLumaRatioRange);
    PARAMETER_INITIALIZE(brightROIAdjustParams);

    result = darkLumaRatioRange.Load(entry, alignment);
    if (result)
    {
        result = darkROIAdjustParams.Load(entry, alignment);
    }
    if (result)
    {
        result = brightLumaRatioRange.Load(entry, alignment);
    }
    if (result)
    {
        result = brightROIAdjustParams.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

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

    return result;
}

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

    PARAMETER_INITIALIZE(enableStartUpBias);
    PARAMETER_INITIALIZE(firstFrameStepSizeDarkMax);
    PARAMETER_INITIALIZE(stepSizeBrightAdjRange);
    PARAMETER_INITIALIZE(maxAdjFactor);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableStartUpBias, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, firstFrameStepSizeDarkMax, alignment)
    if (result)
    {
        result = stepSizeBrightAdjRange.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxAdjFactor, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(firstFrameBias);
    PARAMETER_INITIALIZE(startExpIndex);
    PARAMETER_INITIALIZE(tolMultUnitStepSize);
    PARAMETER_INITIALIZE(frameSkipInit);
    PARAMETER_INITIALIZE(frameSkip);
    PARAMETER_INITIALIZE(minSettledCount);
    PARAMETER_INITIALIZE(maxFrameConvTimeOut);

    result = firstFrameBias.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, startExpIndex, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, tolMultUnitStepSize, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frameSkipInit, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frameSkip, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, minSettledCount, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, maxFrameConvTimeOut, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(customInteger);

    result = aecglobalelements::ReadEnum_AECSwitchCounterEnumType(entry, type, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, customInteger, alignment)

    return result;
}

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

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

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

    return result;
}

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

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

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