////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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 V7.4.1 (8cca6579792b9fcef3bc725ff070c5ec453c7c85)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;

    (void)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;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxLumaTargetZoneDataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxLumaTargetZoneDataType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(lumaTarget);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xbebe3b9355fe9185;
        entry->ReadSimpleTypeFixedArray(&lumaTarget, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxLumaTargetZoneDataType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxLumaTargetZoneDataType* arrayPtr = (LuxLumaTargetZoneDataType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxLumaTargetZoneDataType::AllocArray(
    UINT32 __count)
{
    LuxLumaTargetZoneDataType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxLumaTargetZoneDataType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load TriggerPointType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TriggerPointType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(start);
    PARAMETER_INITIALIZE(end);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb66cc2e0745d14d1;
        entry->ReadSimpleTypeFixedArray(&start, 1, localParams);
        localParams.NameHash = 0xb70a3330100fb825;
        entry->ReadSimpleTypeFixedArray(&end, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void TriggerPointType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        TriggerPointType* arrayPtr = (TriggerPointType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* TriggerPointType::AllocArray(
    UINT32 __count)
{
    TriggerPointType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW TriggerPointType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxLumaTargetZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxLumaTargetZoneType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x9d49dd7376f3949b;
        zoneTrigger.Load(localParams);
        localParams.NameHash        = 0xd47d0038091ab64b;
        zoneData.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxLumaTargetZoneType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxLumaTargetZoneType* arrayPtr = (LuxLumaTargetZoneType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxLumaTargetZoneType::AllocArray(
    UINT32 __count)
{
    LuxLumaTargetZoneType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxLumaTargetZoneType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxLumaTargetType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxLumaTargetType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(luxLumaTargetZoneCount);
    PARAMETER_INITIALIZE(luxLumaTargetZone);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xde44e7697f0d9d44;
        entry->ReadStructureArray(luxLumaTargetZone, luxLumaTargetZoneCount, luxLumaTargetZoneID, 1, localParams, __COUNTER__);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxLumaTargetType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxLumaTargetType* arrayPtr = (LuxLumaTargetType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxLumaTargetType::AllocArray(
    UINT32 __count)
{
    LuxLumaTargetType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxLumaTargetType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load StartEndType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void StartEndType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(start);
    PARAMETER_INITIALIZE(end);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb66cc2e0745d14d1;
        entry->ReadSimpleTypeFixedArray(&start, 1, localParams);
        localParams.NameHash = 0xb70a3330100fb825;
        entry->ReadSimpleTypeFixedArray(&end, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void StartEndType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        StartEndType* arrayPtr = (StartEndType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* StartEndType::AllocArray(
    UINT32 __count)
{
    StartEndType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW StartEndType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxFaceWeightZoneDataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxFaceWeightZoneDataType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(LuxFaceWeight);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xe02a2d9f7ffc23e8;
        LuxFaceWeight.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxFaceWeightZoneDataType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxFaceWeightZoneDataType* arrayPtr = (LuxFaceWeightZoneDataType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxFaceWeightZoneDataType::AllocArray(
    UINT32 __count)
{
    LuxFaceWeightZoneDataType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxFaceWeightZoneDataType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxFaceWeightZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxFaceWeightZoneType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x9d49dd7376f3949b;
        zoneTrigger.Load(localParams);
        localParams.NameHash        = 0xd47d0038091ab64b;
        zoneData.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxFaceWeightZoneType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxFaceWeightZoneType* arrayPtr = (LuxFaceWeightZoneType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxFaceWeightZoneType::AllocArray(
    UINT32 __count)
{
    LuxFaceWeightZoneType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxFaceWeightZoneType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxFaceWeightType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxFaceWeightType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(LuxFaceWeightZoneCount);
    PARAMETER_INITIALIZE(LuxFaceWeightZone);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0x8029f89f975e2861;
        entry->ReadStructureArray(LuxFaceWeightZone, LuxFaceWeightZoneCount, LuxFaceWeightZoneID, 1, localParams, __COUNTER__);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxFaceWeightType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxFaceWeightType* arrayPtr = (LuxFaceWeightType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxFaceWeightType::AllocArray(
    UINT32 __count)
{
    LuxFaceWeightType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxFaceWeightType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxTrackerWeightZoneDataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxTrackerWeightZoneDataType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(LuxTrackerWeight);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xf40b6b0bbb7a8e6f;
        LuxTrackerWeight.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxTrackerWeightZoneDataType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxTrackerWeightZoneDataType* arrayPtr = (LuxTrackerWeightZoneDataType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxTrackerWeightZoneDataType::AllocArray(
    UINT32 __count)
{
    LuxTrackerWeightZoneDataType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxTrackerWeightZoneDataType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxTrackerWeightZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxTrackerWeightZoneType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x9d49dd7376f3949b;
        zoneTrigger.Load(localParams);
        localParams.NameHash        = 0xd47d0038091ab64b;
        zoneData.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxTrackerWeightZoneType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxTrackerWeightZoneType* arrayPtr = (LuxTrackerWeightZoneType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxTrackerWeightZoneType::AllocArray(
    UINT32 __count)
{
    LuxTrackerWeightZoneType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxTrackerWeightZoneType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load LuxTrackerWeightType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxTrackerWeightType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(LuxTrackerWeightZoneCount);
    PARAMETER_INITIALIZE(LuxTrackerWeightZone);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb02ef2cba7b2abdb;
        entry->ReadStructureArray(LuxTrackerWeightZone, LuxTrackerWeightZoneCount, LuxTrackerWeightZoneID, 1, localParams, __COUNTER__);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void LuxTrackerWeightType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        LuxTrackerWeightType* arrayPtr = (LuxTrackerWeightType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* LuxTrackerWeightType::AllocArray(
    UINT32 __count)
{
    LuxTrackerWeightType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW LuxTrackerWeightType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load AECIirFltrCfgType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECIirFltrCfgType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(numOfSamples);
    PARAMETER_INITIALIZE(coeffNumerator);
    PARAMETER_INITIALIZE(coeffDenominator);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xe9cb3aeedc6608b1;
        entry->ReadSimpleTypeFixedArray(&numOfSamples, 1, localParams);
        localParams.NameHash = 0xe4210be036f4bfdb;
        entry->ReadSimpleTypeFixedArray(&coeffNumerator, 1, localParams);
        localParams.NameHash = 0xc3311fdcc3473132;
        entry->ReadSimpleTypeFixedArray(&coeffDenominator, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void AECIirFltrCfgType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        AECIirFltrCfgType* arrayPtr = (AECIirFltrCfgType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* AECIirFltrCfgType::AllocArray(
    UINT32 __count)
{
    AECIirFltrCfgType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW AECIirFltrCfgType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load AECMvavgFltrCfgType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECMvavgFltrCfgType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(numOfSamples);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xe9cb3aeedc6608b1;
        entry->ReadSimpleTypeFixedArray(&numOfSamples, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void AECMvavgFltrCfgType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        AECMvavgFltrCfgType* arrayPtr = (AECMvavgFltrCfgType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* AECMvavgFltrCfgType::AllocArray(
    UINT32 __count)
{
    AECMvavgFltrCfgType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW AECMvavgFltrCfgType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load AECMedianFltrCfgType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECMedianFltrCfgType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(numOfSamples);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xe9cb3aeedc6608b1;
        entry->ReadSimpleTypeFixedArray(&numOfSamples, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void AECMedianFltrCfgType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        AECMedianFltrCfgType* arrayPtr = (AECMedianFltrCfgType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* AECMedianFltrCfgType::AllocArray(
    UINT32 __count)
{
    AECMedianFltrCfgType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW AECMedianFltrCfgType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load AECSensProfileType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECSensProfileType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(triggerThreshold);
    PARAMETER_INITIALIZE(consecutiveCountThreshold);
    PARAMETER_INITIALIZE(frameToArmed);
    PARAMETER_INITIALIZE(medianFltrCfg);
    PARAMETER_INITIALIZE(mvavgFltrCfg);
    PARAMETER_INITIALIZE(IIRFltrCfg);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0x8b18d437338d28d6;
        entry->ReadSimpleTypeFixedArray(&triggerThreshold, 1, localParams);
        localParams.NameHash = 0x8411f71d0b12e8fb;
        entry->ReadSimpleTypeFixedArray(&consecutiveCountThreshold, 1, localParams);
        localParams.NameHash = 0x9f3569bee3a88927;
        entry->ReadSimpleTypeFixedArray(&frameToArmed, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xe5a43ee2c27668b7;
        medianFltrCfg.Load(localParams);
        localParams.NameHash        = 0x880285824b22ba04;
        mvavgFltrCfg.Load(localParams);
        localParams.NameHash        = 0x97434dc604b53e61;
        IIRFltrCfg.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void AECSensProfileType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        AECSensProfileType* arrayPtr = (AECSensProfileType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* AECSensProfileType::AllocArray(
    UINT32 __count)
{
    AECSensProfileType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW AECSensProfileType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load AECAbsoluteModeCfgType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECAbsoluteModeCfgType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(baseline);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xd0d05e75d1551cd4;
        entry->ReadSimpleTypeFixedArray(&baseline, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void AECAbsoluteModeCfgType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        AECAbsoluteModeCfgType* arrayPtr = (AECAbsoluteModeCfgType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* AECAbsoluteModeCfgType::AllocArray(
    UINT32 __count)
{
    AECAbsoluteModeCfgType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW AECAbsoluteModeCfgType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load AECValueMonitorType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void AECValueMonitorType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(detectionType);
    PARAMETER_INITIALIZE(absoluteModeCfg);
    PARAMETER_INITIALIZE(sensProfileLow);
    PARAMETER_INITIALIZE(sensProfileMed);
    PARAMETER_INITIALIZE(sensProfileHigh);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0x89777bfc140b1266;
        entry->ReadEnumFixedArray(&detectionType, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xeaeb90f8d02ef678;
        absoluteModeCfg.Load(localParams);
        localParams.NameHash        = 0xe53187c74b4b634e;
        sensProfileLow.Load(localParams);
        localParams.NameHash        = 0xce972eab413f7795;
        sensProfileMed.Load(localParams);
        localParams.NameHash        = 0x9973dfba56d5c9d0;
        sensProfileHigh.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void AECValueMonitorType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        AECValueMonitorType* arrayPtr = (AECValueMonitorType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* AECValueMonitorType::AllocArray(
    UINT32 __count)
{
    AECValueMonitorType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW AECValueMonitorType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load HistTargetAdjustParamType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void HistTargetAdjustParamType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(minTargetAdjRatio);
    PARAMETER_INITIALIZE(maxTargetAdjRatio);
    PARAMETER_INITIALIZE(darkRefLow);
    PARAMETER_INITIALIZE(satRefHigh);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xf4583bb66e49a85d;
        entry->ReadSimpleTypeFixedArray(&minTargetAdjRatio, 1, localParams);
        localParams.NameHash = 0xe10fb336ea2a09e3;
        entry->ReadSimpleTypeFixedArray(&maxTargetAdjRatio, 1, localParams);
        localParams.NameHash = 0xa2ca69f86ce5ef8f;
        entry->ReadSimpleTypeFixedArray(&darkRefLow, 1, localParams);
        localParams.NameHash = 0xa6543ba4c5e69cd0;
        entry->ReadSimpleTypeFixedArray(&satRefHigh, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void HistTargetAdjustParamType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        HistTargetAdjustParamType* arrayPtr = (HistTargetAdjustParamType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* HistTargetAdjustParamType::AllocArray(
    UINT32 __count)
{
    HistTargetAdjustParamType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW HistTargetAdjustParamType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load ROIHistAdjZoneDataType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ROIHistAdjZoneDataType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(darkLumaRatioRange);
    PARAMETER_INITIALIZE(darkROIAdjustParams);
    PARAMETER_INITIALIZE(brightLumaRatioRange);
    PARAMETER_INITIALIZE(brightROIAdjustParams);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x9be27b6dc0e84d7f;
        darkLumaRatioRange.Load(localParams);
        localParams.NameHash        = 0xdbc2db1ca604868e;
        darkROIAdjustParams.Load(localParams);
        localParams.NameHash        = 0xd1b1aada96d275a2;
        brightLumaRatioRange.Load(localParams);
        localParams.NameHash        = 0xa65ba2eb91d5c208;
        brightROIAdjustParams.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void ROIHistAdjZoneDataType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        ROIHistAdjZoneDataType* arrayPtr = (ROIHistAdjZoneDataType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* ROIHistAdjZoneDataType::AllocArray(
    UINT32 __count)
{
    ROIHistAdjZoneDataType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW ROIHistAdjZoneDataType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load ROIHistAdjZoneType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ROIHistAdjZoneType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(zoneTrigger);
    PARAMETER_INITIALIZE(zoneData);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x9d49dd7376f3949b;
        zoneTrigger.Load(localParams);
        localParams.NameHash        = 0xd47d0038091ab64b;
        zoneData.Load(localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void ROIHistAdjZoneType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        ROIHistAdjZoneType* arrayPtr = (ROIHistAdjZoneType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* ROIHistAdjZoneType::AllocArray(
    UINT32 __count)
{
    ROIHistAdjZoneType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW ROIHistAdjZoneType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load FirstFrameBiasType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FirstFrameBiasType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enableStartUpBias);
    PARAMETER_INITIALIZE(firstFrameStepSizeDarkMax);
    PARAMETER_INITIALIZE(stepSizeBrightAdjRange);
    PARAMETER_INITIALIZE(maxAdjFactor);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0x9165c771582b0c4b;
        entry->ReadSimpleTypeFixedArray(&enableStartUpBias, 1, localParams);
        localParams.NameHash = 0xa17fb68466c4371f;
        entry->ReadSimpleTypeFixedArray(&firstFrameStepSizeDarkMax, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x8a64201047138f3e;
        stepSizeBrightAdjRange.Load(localParams);
        localParams.NameHash = 0xdbcbe75785edf66c;
        entry->ReadSimpleTypeFixedArray(&maxAdjFactor, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void FirstFrameBiasType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        FirstFrameBiasType* arrayPtr = (FirstFrameBiasType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* FirstFrameBiasType::AllocArray(
    UINT32 __count)
{
    FirstFrameBiasType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW FirstFrameBiasType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load RapidConvType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RapidConvType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(firstFrameBias);
    PARAMETER_INITIALIZE(startExpIndex);
    PARAMETER_INITIALIZE(tolMultUnitStepSize);
    PARAMETER_INITIALIZE(frameSkipInit);
    PARAMETER_INITIALIZE(frameSkip);
    PARAMETER_INITIALIZE(minSettledCount);
    PARAMETER_INITIALIZE(maxFrameConvTimeOut);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xdf449804a80bb075;
        firstFrameBias.Load(localParams);
        localParams.NameHash = 0xc972ab892bd2da3e;
        entry->ReadSimpleTypeFixedArray(&startExpIndex, 1, localParams);
        localParams.NameHash = 0x81e76a4469bbd0c5;
        entry->ReadSimpleTypeFixedArray(&tolMultUnitStepSize, 1, localParams);
        localParams.NameHash = 0x8c12416921444d72;
        entry->ReadSimpleTypeFixedArray(&frameSkipInit, 1, localParams);
        localParams.NameHash = 0x8da123b1454f5754;
        entry->ReadSimpleTypeFixedArray(&frameSkip, 1, localParams);
        localParams.NameHash = 0xbacf1e94d1720cdd;
        entry->ReadSimpleTypeFixedArray(&minSettledCount, 1, localParams);
        localParams.NameHash = 0xd291c9870909eca1;
        entry->ReadSimpleTypeFixedArray(&maxFrameConvTimeOut, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void RapidConvType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        RapidConvType* arrayPtr = (RapidConvType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* RapidConvType::AllocArray(
    UINT32 __count)
{
    RapidConvType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW RapidConvType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load SwitchCounterType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SwitchCounterType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(customInteger);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xd7a23f43d1e0d686;
        entry->ReadEnumFixedArray(&type, 1, localParams);
        localParams.NameHash = 0xe42bb6d4ecef0751;
        entry->ReadSimpleTypeFixedArray(&customInteger, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void SwitchCounterType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        SwitchCounterType* arrayPtr = (SwitchCounterType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* SwitchCounterType::AllocArray(
    UINT32 __count)
{
    SwitchCounterType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW SwitchCounterType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load ModuleVersionType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ModuleVersionType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(major_revision);
    PARAMETER_INITIALIZE(minor_revision);
    PARAMETER_INITIALIZE(incr_revision);

    ParameterFileSymbolTableEntry* const entry = parentParams.Entry;
    ParameterLoadParameters localParams(parentParams);
    localParams.Element   = nullptr;
    localParams.UseParent = false;
    localParams.Index     = 0;

    if (parentParams.Element != nullptr)
    {
        bool _posChanged = false;
        localParams.Element = entry->AdjustPositionAndGetElement(parentParams, true, _posChanged);
    }

    // If parentParams.Element != null && localParams.Element == null, then this element is not defined in the binary file.
    // If parentParams.Element == null then this binary file does not contain a definition table or
    // the full backwards compatibility feature is disabled (for memory or performance reasons)
    if (parentParams.Element == nullptr || parentParams.Element->Verified || localParams.Element != nullptr)
    {
        localParams.Position      = entry->Position;
        localParams.LoadDataLimit = entry->ReadLoadDataLimit(parentParams.LoadDataLimit);

        localParams.NameHash = 0xcd66249477636693;
        entry->ReadSimpleTypeFixedArray(&major_revision, 1, localParams);
        localParams.NameHash = 0xc5497493137a9c25;
        entry->ReadSimpleTypeFixedArray(&minor_revision, 1, localParams);
        localParams.NameHash = 0xb27b8a668efb2a56;
        entry->ReadSimpleTypeFixedArray(&incr_revision, 1, localParams);

        entry->UpdatePosition(localParams.LoadDataLimit);
    }
    else
    {
        PARAMETER_LOG_ERROR(entry->Table->SetManager, "%s: 0x%llx entry not found in the binary file, all values will be 0\n",
            __FUNCTION__, parentParams.NameHash);
    }
}

void ModuleVersionType::LoadArray(
    ParameterLoadParameters& __params,
    void*                    __array,
    UINT32                   __count)
{
    if (__array != nullptr)
    {
        ModuleVersionType* arrayPtr = (ModuleVersionType*)__array;
        for (UINT32 i = 0; i < __count; i++)
        {
            __params.Index = i;
            arrayPtr[i].Load(__params);
        }
    }
}

void* ModuleVersionType::AllocArray(
    UINT32 __count)
{
    ModuleVersionType* result = nullptr;
    if (__count > 0)
    {
        result = PARAMETER_NEW ModuleVersionType[__count];
    }
    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LuxLumaTargetType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxLumaTargetType::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, luxLumaTargetZone);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LuxFaceWeightType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxFaceWeightType::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, LuxFaceWeightZone);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload LuxTrackerWeightType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LuxTrackerWeightType::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, LuxTrackerWeightZone);
}
AECGLOBALELEMENTS_NAMESPACE_END
