////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: Parameter Parser V5.5.1 (2411131018)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afcontrastafelements.cpp
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "afcontrastafelements.h"
#include "parametersetmanager.h"

AFCONTRASTAFELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool chromatixAFStepBackReserveType::GetValue(
    const CHAR* const __path,
    CHAR* const       __value,
    UINT32 const      __size)
{
    constexpr SIZE_T MAX_SIZE = 129;
    CHAR   __name[MAX_SIZE] = "";
    UINT32 __index          = MAX_UINT;
    bool   __result         = false;

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

    if (PARAMETER_STRCMP(__name, "stepBackEnable") == 0)
    {
        ParameterUtils::DoubleToString((double)stepBackEnable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stepBackStartInfinity") == 0)
    {
        ParameterUtils::DoubleToString((double)stepBackStartInfinity, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stepBackReverseInfinity") == 0)
    {
        ParameterUtils::DoubleToString((double)stepBackReverseInfinity, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stepBackStartMacro") == 0)
    {
        ParameterUtils::DoubleToString((double)stepBackStartMacro, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stepBackReverseMacro") == 0)
    {
        ParameterUtils::DoubleToString((double)stepBackReverseMacro, __value, __size, 0);
        __result = true;
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "stepBackEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stepBackEnable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stepBackStartInfinity") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stepBackStartInfinity = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stepBackReverseInfinity") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stepBackReverseInfinity = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stepBackStartMacro") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stepBackStartMacro = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stepBackReverseMacro") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stepBackReverseMacro = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enableHVStatsRatio") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableHVStatsRatio = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hvFocusValueWeight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            hvFocusValueWeight = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "exposureCompensationEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            exposureCompensationEnable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "kickinProgress") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            kickinProgress = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixFaceTableType::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, "numEntries") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numEntries = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "indexEntries") == 0)
    {
        if (__index < indexEntriesCount)
        {
            __result = indexEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixLumaTableType::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, "numEntries") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numEntries = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "lumaEntries") == 0)
    {
        if (__index < lumaEntriesCount)
        {
            __result = lumaEntries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "numEntries") == 0)
    {
        ParameterUtils::DoubleToString((double)numEntries, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "weight") == 0)
    {
        if (__index < weightCount)
        {
            ParameterUtils::DoubleToString((double)weight[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < weightCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)weight[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "numEntries") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numEntries = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "weight") == 0)
    {
        if (__index < weightCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                weight[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

bool chromatixAFWeightedWindowReserveType::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, "enableAFRegionWeightTable") == 0)
    {
        ParameterUtils::DoubleToString((double)enableAFRegionWeightTable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "AFRegionWeightTable") == 0)
    {
        __result = AFRegionWeightTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enableAFLumaWeightTable") == 0)
    {
        ParameterUtils::DoubleToString((double)enableAFLumaWeightTable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "AFLumaWeightTable") == 0)
    {
        __result = AFLumaWeightTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "enableAFFaceWeightTable") == 0)
    {
        ParameterUtils::DoubleToString((double)enableAFFaceWeightTable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "AFFaceWeightTable") == 0)
    {
        __result = AFFaceWeightTable.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixAFWeightedWindowReserveType::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, "enableAFRegionWeightTable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableAFRegionWeightTable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "AFRegionWeightTable") == 0)
    {
        __result = AFRegionWeightTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enableAFLumaWeightTable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableAFLumaWeightTable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "AFLumaWeightTable") == 0)
    {
        __result = AFLumaWeightTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enableAFFaceWeightTable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableAFFaceWeightTable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "AFFaceWeightTable") == 0)
    {
        __result = AFFaceWeightTable.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "baseFrameDelay") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            baseFrameDelay = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "coarseFrameDelay") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            coarseFrameDelay = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fineFrameDelay") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fineFrameDelay = (UINT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "CAFFarEnd") == 0)
    {
        ParameterUtils::DoubleToString((double)CAFFarEnd, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "CAFNearEnd") == 0)
    {
        ParameterUtils::DoubleToString((double)CAFNearEnd, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TAFFarEnd") == 0)
    {
        ParameterUtils::DoubleToString((double)TAFFarEnd, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TAFNearEnd") == 0)
    {
        ParameterUtils::DoubleToString((double)TAFNearEnd, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "searchRegion1") == 0)
    {
        ParameterUtils::DoubleToString((double)searchRegion1, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "searchRegion2") == 0)
    {
        ParameterUtils::DoubleToString((double)searchRegion2, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "searchRegion3") == 0)
    {
        ParameterUtils::DoubleToString((double)searchRegion3, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fineSearchRegion") == 0)
    {
        ParameterUtils::DoubleToString((double)fineSearchRegion, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "farZone") == 0)
    {
        ParameterUtils::DoubleToString((double)farZone, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "nearZone") == 0)
    {
        ParameterUtils::DoubleToString((double)nearZone, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "midZone") == 0)
    {
        ParameterUtils::DoubleToString((double)midZone, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "farStartPosition") == 0)
    {
        ParameterUtils::DoubleToString((double)farStartPosition, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "nearStartPosition") == 0)
    {
        ParameterUtils::DoubleToString((double)nearStartPosition, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "initialPosition") == 0)
    {
        ParameterUtils::DoubleToString((double)initialPosition, __value, __size, 0);
        __result = true;
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "CAFFarEnd") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            CAFFarEnd = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "CAFNearEnd") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            CAFNearEnd = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TAFFarEnd") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TAFFarEnd = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TAFNearEnd") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            TAFNearEnd = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "searchRegion1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            searchRegion1 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "searchRegion2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            searchRegion2 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "searchRegion3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            searchRegion3 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fineSearchRegion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fineSearchRegion = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "farZone") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            farZone = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "nearZone") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            nearZone = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "midZone") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            midZone = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "farStartPosition") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            farStartPosition = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "nearStartPosition") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            nearStartPosition = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "initialPosition") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            initialPosition = (UINT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "Threshold") == 0)
    {
        if (__index < 8)
        {
            ParameterUtils::DoubleToString((double)Threshold[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 8; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)Threshold[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "Threshold") == 0)
    {
        if (__index < 8)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                Threshold[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

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

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

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

    return __result;
}

bool chromatixSingleThreshold::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, "changeRatioInc") == 0)
    {
        ParameterUtils::DoubleToString((double)changeRatioInc, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "changeRatioDec") == 0)
    {
        ParameterUtils::DoubleToString((double)changeRatioDec, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "flatIncThres") == 0)
    {
        ParameterUtils::DoubleToString((double)flatIncThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "flatDecThres") == 0)
    {
        ParameterUtils::DoubleToString((double)flatDecThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fvIncFlatThres") == 0)
    {
        ParameterUtils::DoubleToString((double)fvIncFlatThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fvDecFlatThres") == 0)
    {
        ParameterUtils::DoubleToString((double)fvDecFlatThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fvIncFlatThresSpotlight") == 0)
    {
        ParameterUtils::DoubleToString((double)fvIncFlatThresSpotlight, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fvDecFlatThresSpotlight") == 0)
    {
        ParameterUtils::DoubleToString((double)fvDecFlatThresSpotlight, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "macroThres") == 0)
    {
        ParameterUtils::DoubleToString((double)macroThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "dropThres") == 0)
    {
        ParameterUtils::DoubleToString((double)dropThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "histogramDecreaseDecreaseThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)histogramDecreaseDecreaseThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "histogramIncreaseDecreaseThreshold") == 0)
    {
        ParameterUtils::DoubleToString((double)histogramIncreaseDecreaseThreshold, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "threeFrameDecreaseDecreasePeakThreshold") == 0)
    {
        __result = threeFrameDecreaseDecreasePeakThreshold.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "threeFrameIncreaseDecreasePeakThreshold") == 0)
    {
        __result = threeFrameIncreaseDecreasePeakThreshold.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "decreaseDecreasePeakThreshold") == 0)
    {
        __result = decreaseDecreasePeakThreshold.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "decreaseDecreasePeakWithNoiseThreshold") == 0)
    {
        __result = decreaseDecreasePeakWithNoiseThreshold.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "increaseDecreasePeakThreshold") == 0)
    {
        __result = increaseDecreasePeakThreshold.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "increaseDecreasePeakWithNoiseThreshold") == 0)
    {
        __result = increaseDecreasePeakWithNoiseThreshold.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "flatThreshold") == 0)
    {
        __result = flatThreshold.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "spotlightFlatThresholdMarco") == 0)
    {
        ParameterUtils::DoubleToString((double)spotlightFlatThresholdMarco, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "spotlightFlatThresholdInfinity") == 0)
    {
        ParameterUtils::DoubleToString((double)spotlightFlatThresholdInfinity, __value, __size);
        __result = true;
    }

    return __result;
}

bool chromatixSingleThreshold::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, "changeRatioInc") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            changeRatioInc = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "changeRatioDec") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            changeRatioDec = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "flatIncThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            flatIncThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "flatDecThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            flatDecThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fvIncFlatThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fvIncFlatThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fvDecFlatThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fvDecFlatThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fvIncFlatThresSpotlight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fvIncFlatThresSpotlight = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fvDecFlatThresSpotlight") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fvDecFlatThresSpotlight = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "macroThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            macroThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dropThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            dropThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "histogramDecreaseDecreaseThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            histogramDecreaseDecreaseThreshold = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "histogramIncreaseDecreaseThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            histogramIncreaseDecreaseThreshold = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "threeFrameDecreaseDecreasePeakThreshold") == 0)
    {
        __result = threeFrameDecreaseDecreasePeakThreshold.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "threeFrameIncreaseDecreasePeakThreshold") == 0)
    {
        __result = threeFrameIncreaseDecreasePeakThreshold.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "decreaseDecreasePeakThreshold") == 0)
    {
        __result = decreaseDecreasePeakThreshold.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "decreaseDecreasePeakWithNoiseThreshold") == 0)
    {
        __result = decreaseDecreasePeakWithNoiseThreshold.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "increaseDecreasePeakThreshold") == 0)
    {
        __result = increaseDecreasePeakThreshold.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "increaseDecreasePeakWithNoiseThreshold") == 0)
    {
        __result = increaseDecreasePeakWithNoiseThreshold.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "flatThreshold") == 0)
    {
        __result = flatThreshold.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "spotlightFlatThresholdMarco") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            spotlightFlatThresholdMarco = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "spotlightFlatThresholdInfinity") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            spotlightFlatThresholdInfinity = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "region0") == 0)
    {
        ParameterUtils::DoubleToString((double)region0, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "region1") == 0)
    {
        ParameterUtils::DoubleToString((double)region1, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "region2") == 0)
    {
        ParameterUtils::DoubleToString((double)region2, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "region3") == 0)
    {
        ParameterUtils::DoubleToString((double)region3, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "region4") == 0)
    {
        ParameterUtils::DoubleToString((double)region4, __value, __size, 0);
        __result = true;
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "region0") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            region0 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "region1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            region1 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "region2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            region2 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "region3") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            region3 = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "region4") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            region4 = (UINT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

bool chromatixAFTuningSingle::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, "index") == 0)
    {
        if (__index < indexCount)
        {
            ParameterUtils::DoubleToString((double)index[__index], __value, __size, 0);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < indexCount; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)index[i], &__value[__valuePos], (INT32)(__size - __valuePos), 0);
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "actuatorType") == 0)
    {
        ParameterUtils::DoubleToString((double)actuatorType, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "isHysteresisCompensationNeeded") == 0)
    {
        ParameterUtils::DoubleToString((double)isHysteresisCompensationNeeded, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "stepIndexPerMicroMeter") == 0)
    {
        ParameterUtils::DoubleToString((double)stepIndexPerMicroMeter, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "previewAssistedAFEnable") == 0)
    {
        ParameterUtils::DoubleToString((double)previewAssistedAFEnable, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "TAFStepTable") == 0)
    {
        __result = TAFStepTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "CAFStepTable") == 0)
    {
        __result = CAFStepTable.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "software") == 0)
    {
        __result = software.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "hardware") == 0)
    {
        __result = hardware.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "optics") == 0)
    {
        __result = optics.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "frameDelay") == 0)
    {
        __result = frameDelay.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "BVGain") == 0)
    {
        if (__index < 8)
        {
            ParameterUtils::DoubleToString((double)BVGain[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 8; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)BVGain[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "ignoreFirstInvalidFrame") == 0)
    {
        ParameterUtils::DoubleToString((double)ignoreFirstInvalidFrame, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool chromatixAFTuningSingle::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, "index") == 0)
    {
        if (__index < indexCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                index[__index] = (UINT32)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    index[__index] = (UINT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "actuatorType") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            actuatorType = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "isHysteresisCompensationNeeded") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            isHysteresisCompensationNeeded = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "stepIndexPerMicroMeter") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            stepIndexPerMicroMeter = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "previewAssistedAFEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            previewAssistedAFEnable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "TAFStepTable") == 0)
    {
        __result = TAFStepTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "CAFStepTable") == 0)
    {
        __result = CAFStepTable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "software") == 0)
    {
        __result = software.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "hardware") == 0)
    {
        __result = hardware.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "optics") == 0)
    {
        __result = optics.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "frameDelay") == 0)
    {
        __result = frameDelay.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "BVGain") == 0)
    {
        if (__index < 8)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                BVGain[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    BVGain[__index] = (float)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "ignoreFirstInvalidFrame") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ignoreFirstInvalidFrame = (globalelements::enable_flag_type)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "numStepsBetweenStatPoints") == 0)
    {
        ParameterUtils::DoubleToString((double)numStepsBetweenStatPoints, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayInf") == 0)
    {
        ParameterUtils::DoubleToString((double)frameDelayInf, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayNorm") == 0)
    {
        ParameterUtils::DoubleToString((double)frameDelayNorm, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayFinal") == 0)
    {
        ParameterUtils::DoubleToString((double)frameDelayFinal, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "previewAssistedAFEnable") == 0)
    {
        ParameterUtils::DoubleToString((double)previewAssistedAFEnable, __value, __size, 0);
        __result = true;
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "numStepsBetweenStatPoints") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numStepsBetweenStatPoints = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayInf") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameDelayInf = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayNorm") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameDelayNorm = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "frameDelayFinal") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            frameDelayFinal = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "previewAssistedAFEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            previewAssistedAFEnable = (globalelements::enable_flag_type)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "statisticsSelection") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)statisticsSelection, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "face") == 0)
    {
        __result = face.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "track") == 0)
    {
        __result = track.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "saliency") == 0)
    {
        __result = saliency.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "fullSweep") == 0)
    {
        __result = fullSweep.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "singleSearch") == 0)
    {
        __result = singleSearch.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "weightedWindow") == 0)
    {
        __result = weightedWindow.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "exposureCompensation") == 0)
    {
        __result = exposureCompensation.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "HVFocusValueStatisticWeighting") == 0)
    {
        __result = HVFocusValueStatisticWeighting.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "stepBack") == 0)
    {
        __result = stepBack.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "parameter_version") == 0)
    {
        __result = parameter_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "statisticsSelection") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            statisticsSelection = (AFStatisticComputationType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "face") == 0)
    {
        __result = face.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "track") == 0)
    {
        __result = track.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "saliency") == 0)
    {
        __result = saliency.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "fullSweep") == 0)
    {
        __result = fullSweep.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "singleSearch") == 0)
    {
        __result = singleSearch.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "weightedWindow") == 0)
    {
        __result = weightedWindow.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "exposureCompensation") == 0)
    {
        __result = exposureCompensation.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "HVFocusValueStatisticWeighting") == 0)
    {
        __result = HVFocusValueStatisticWeighting.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "stepBack") == 0)
    {
        __result = stepBack.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixContrastAFType::faceStruct::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, "ROIProcessEnable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ROIProcessEnable = (globalelements::enable_flag_type)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ROIStable") == 0)
    {
        __result = ROIStable.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "ROIChange") == 0)
    {
        __result = ROIChange.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AFStatisticComputationType::AF_StatsH1):
            enumValue = AFStatisticComputationType::AF_StatsH1;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AFStatsH1_NORM):
            enumValue = AFStatisticComputationType::AFStatsH1_NORM;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AF_StatsH2):
            enumValue = AFStatisticComputationType::AF_StatsH2;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AFStatsH2_NORM):
            enumValue = AFStatisticComputationType::AFStatsH2_NORM;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AF_Stats_V):
            enumValue = AFStatisticComputationType::AF_Stats_V;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AFStats_V_NORM):
            enumValue = AFStatisticComputationType::AFStats_V_NORM;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AF_Stats_HV):
            enumValue = AFStatisticComputationType::AF_Stats_HV;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AF_Stats_HV_NORM):
            enumValue = AFStatisticComputationType::AF_Stats_HV_NORM;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AF_Stats_Scale):
            enumValue = AFStatisticComputationType::AF_Stats_Scale;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AF_Stats_Scale_NORM):
            enumValue = AFStatisticComputationType::AF_Stats_Scale_NORM;
            result    = true;
            break;
        case static_cast<UINT32>(AFStatisticComputationType::AF_Stats_MAX):
            enumValue = AFStatisticComputationType::AF_Stats_MAX;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AFStatisticComputationType", uintValue);
            break;
        }
    }
    return result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(singleIndex::SINGLE_NEAR_LIMIT_IDX):
            enumValue = singleIndex::SINGLE_NEAR_LIMIT_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_7CM_IDX):
            enumValue = singleIndex::SINGLE_7CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_10CM_IDX):
            enumValue = singleIndex::SINGLE_10CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_14CM_IDX):
            enumValue = singleIndex::SINGLE_14CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_20CM_IDX):
            enumValue = singleIndex::SINGLE_20CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_30CM_IDX):
            enumValue = singleIndex::SINGLE_30CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_40CM_IDX):
            enumValue = singleIndex::SINGLE_40CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_50CM_IDX):
            enumValue = singleIndex::SINGLE_50CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_60CM_IDX):
            enumValue = singleIndex::SINGLE_60CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_120CM_IDX):
            enumValue = singleIndex::SINGLE_120CM_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_HYP_F_IDX):
            enumValue = singleIndex::SINGLE_HYP_F_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_INF_LIMIT_IDX):
            enumValue = singleIndex::SINGLE_INF_LIMIT_IDX;
            result    = true;
            break;
        case static_cast<UINT32>(singleIndex::SINGLE_MAX_IDX):
            enumValue = singleIndex::SINGLE_MAX_IDX;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to singleIndex", uintValue);
            break;
        }
    }
    return result;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixContrastAFTypeClass::chromatixContrastAFTypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(statisticsSelection);
    PARAMETER_INITIALIZE(face);
    PARAMETER_INITIALIZE(track);
    PARAMETER_INITIALIZE(saliency);
    PARAMETER_INITIALIZE(fullSweep);
    PARAMETER_INITIALIZE(singleSearch);
    PARAMETER_INITIALIZE(weightedWindow);
    PARAMETER_INITIALIZE(exposureCompensation);
    PARAMETER_INITIALIZE(HVFocusValueStatisticWeighting);
    PARAMETER_INITIALIZE(stepBack);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixContrastAFTypeClass::chromatixContrastAFTypeClass(
    const CHAR* const name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(statisticsSelection);
    PARAMETER_INITIALIZE(face);
    PARAMETER_INITIALIZE(track);
    PARAMETER_INITIALIZE(saliency);
    PARAMETER_INITIALIZE(fullSweep);
    PARAMETER_INITIALIZE(singleSearch);
    PARAMETER_INITIALIZE(weightedWindow);
    PARAMETER_INITIALIZE(exposureCompensation);
    PARAMETER_INITIALIZE(HVFocusValueStatisticWeighting);
    PARAMETER_INITIALIZE(stepBack);
}

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

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

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

    PARAMETER_INITIALIZE(stepBackEnable);
    PARAMETER_INITIALIZE(stepBackStartInfinity);
    PARAMETER_INITIALIZE(stepBackReverseInfinity);
    PARAMETER_INITIALIZE(stepBackStartMacro);
    PARAMETER_INITIALIZE(stepBackReverseMacro);

    SYMBOL_TABLE_ENTRY_READ(entry, result, stepBackEnable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, stepBackStartInfinity, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, stepBackReverseInfinity, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, stepBackStartMacro, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, stepBackReverseMacro, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enableHVStatsRatio);
    PARAMETER_INITIALIZE(hvFocusValueWeight);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableHVStatsRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, hvFocusValueWeight, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(exposureCompensationEnable);
    PARAMETER_INITIALIZE(kickinProgress);

    SYMBOL_TABLE_ENTRY_READ(entry, result, exposureCompensationEnable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, kickinProgress, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(fvIndex);
    PARAMETER_INITIALIZE(weight);

    SYMBOL_TABLE_ENTRY_READ(entry, result, fvIndex, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, weight, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(numEntries);
    PARAMETER_INITIALIZE(indexEntries);

    SYMBOL_TABLE_ENTRY_READ(entry, result, numEntries, alignment)

    // Reading Array indexEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        indexEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, indexEntriesCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            indexEntriesID = pointerEntry->ID;
            DupObjInfo* indexEntriesDupInfo = pointerEntry->GetDupObject(indexEntriesCount, file, line);
            if (indexEntriesDupInfo != nullptr && indexEntriesDupInfo->Object != nullptr)
            {
                indexEntries = (chromatixFaceTableEntryType*)indexEntriesDupInfo->Object;
                if (indexEntries == nullptr)
                {
                    if (indexEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "indexEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            indexEntriesDupInfo->File, indexEntriesDupInfo->Line, indexEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "indexEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            indexEntriesDupInfo->Line, indexEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(luma);
    PARAMETER_INITIALIZE(weight);

    SYMBOL_TABLE_ENTRY_READ(entry, result, luma, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, weight, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(numEntries);
    PARAMETER_INITIALIZE(lumaEntries);

    SYMBOL_TABLE_ENTRY_READ(entry, result, numEntries, alignment)

    // Reading Array lumaEntries from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        lumaEntriesCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, lumaEntriesCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            lumaEntriesID = pointerEntry->ID;
            DupObjInfo* lumaEntriesDupInfo = pointerEntry->GetDupObject(lumaEntriesCount, file, line);
            if (lumaEntriesDupInfo != nullptr && lumaEntriesDupInfo->Object != nullptr)
            {
                lumaEntries = (chromatixLumaTableEntryType*)lumaEntriesDupInfo->Object;
                if (lumaEntries == nullptr)
                {
                    if (lumaEntriesDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "lumaEntries duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            lumaEntriesDupInfo->File, lumaEntriesDupInfo->Line, lumaEntriesDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "lumaEntries duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            lumaEntriesDupInfo->Line, lumaEntriesDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(numEntries);
    PARAMETER_INITIALIZE(weight);

    SYMBOL_TABLE_ENTRY_READ(entry, result, numEntries, alignment)

    // Reading Array weight from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        weightCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, weightCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            weightID = pointerEntry->ID;
            DupObjInfo* weightDupInfo = pointerEntry->GetDupObject(weightCount, file, line);
            if (weightDupInfo != nullptr && weightDupInfo->Object != nullptr)
            {
                weight = (float*)weightDupInfo->Object;
                if (weight == nullptr)
                {
                    if (weightDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "weight duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            weightDupInfo->File, weightDupInfo->Line, weightDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "weight duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            weightDupInfo->Line, weightDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(enableAFRegionWeightTable);
    PARAMETER_INITIALIZE(AFRegionWeightTable);
    PARAMETER_INITIALIZE(enableAFLumaWeightTable);
    PARAMETER_INITIALIZE(AFLumaWeightTable);
    PARAMETER_INITIALIZE(enableAFFaceWeightTable);
    PARAMETER_INITIALIZE(AFFaceWeightTable);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableAFRegionWeightTable, alignment)
    if (result)
    {
        result = AFRegionWeightTable.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableAFLumaWeightTable, alignment)
    if (result)
    {
        result = AFLumaWeightTable.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableAFFaceWeightTable, alignment)
    if (result)
    {
        result = AFFaceWeightTable.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(baseFrameDelay);
    PARAMETER_INITIALIZE(coarseFrameDelay);
    PARAMETER_INITIALIZE(fineFrameDelay);

    SYMBOL_TABLE_ENTRY_READ(entry, result, baseFrameDelay, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, coarseFrameDelay, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fineFrameDelay, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(CAFFarEnd);
    PARAMETER_INITIALIZE(CAFNearEnd);
    PARAMETER_INITIALIZE(TAFFarEnd);
    PARAMETER_INITIALIZE(TAFNearEnd);
    PARAMETER_INITIALIZE(searchRegion1);
    PARAMETER_INITIALIZE(searchRegion2);
    PARAMETER_INITIALIZE(searchRegion3);
    PARAMETER_INITIALIZE(fineSearchRegion);
    PARAMETER_INITIALIZE(farZone);
    PARAMETER_INITIALIZE(nearZone);
    PARAMETER_INITIALIZE(midZone);
    PARAMETER_INITIALIZE(farStartPosition);
    PARAMETER_INITIALIZE(nearStartPosition);
    PARAMETER_INITIALIZE(initialPosition);

    SYMBOL_TABLE_ENTRY_READ(entry, result, CAFFarEnd, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, CAFNearEnd, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TAFFarEnd, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, TAFNearEnd, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, searchRegion1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, searchRegion2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, searchRegion3, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fineSearchRegion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, farZone, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, nearZone, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, midZone, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, farStartPosition, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, nearStartPosition, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, initialPosition, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(Threshold);

    result = entry->ReadArray(Threshold, 8, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(changeRatioInc);
    PARAMETER_INITIALIZE(changeRatioDec);
    PARAMETER_INITIALIZE(flatIncThres);
    PARAMETER_INITIALIZE(flatDecThres);
    PARAMETER_INITIALIZE(fvIncFlatThres);
    PARAMETER_INITIALIZE(fvDecFlatThres);
    PARAMETER_INITIALIZE(fvIncFlatThresSpotlight);
    PARAMETER_INITIALIZE(fvDecFlatThresSpotlight);
    PARAMETER_INITIALIZE(macroThres);
    PARAMETER_INITIALIZE(dropThres);
    PARAMETER_INITIALIZE(histogramDecreaseDecreaseThreshold);
    PARAMETER_INITIALIZE(histogramIncreaseDecreaseThreshold);
    PARAMETER_INITIALIZE(threeFrameDecreaseDecreasePeakThreshold);
    PARAMETER_INITIALIZE(threeFrameIncreaseDecreasePeakThreshold);
    PARAMETER_INITIALIZE(decreaseDecreasePeakThreshold);
    PARAMETER_INITIALIZE(decreaseDecreasePeakWithNoiseThreshold);
    PARAMETER_INITIALIZE(increaseDecreasePeakThreshold);
    PARAMETER_INITIALIZE(increaseDecreasePeakWithNoiseThreshold);
    PARAMETER_INITIALIZE(flatThreshold);
    PARAMETER_INITIALIZE(spotlightFlatThresholdMarco);
    PARAMETER_INITIALIZE(spotlightFlatThresholdInfinity);

    SYMBOL_TABLE_ENTRY_READ(entry, result, changeRatioInc, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, changeRatioDec, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, flatIncThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, flatDecThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fvIncFlatThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fvDecFlatThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fvIncFlatThresSpotlight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fvDecFlatThresSpotlight, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, macroThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, dropThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, histogramDecreaseDecreaseThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, histogramIncreaseDecreaseThreshold, alignment)
    if (result)
    {
        result = threeFrameDecreaseDecreasePeakThreshold.Load(entry, alignment);
    }
    if (result)
    {
        result = threeFrameIncreaseDecreasePeakThreshold.Load(entry, alignment);
    }
    if (result)
    {
        result = decreaseDecreasePeakThreshold.Load(entry, alignment);
    }
    if (result)
    {
        result = decreaseDecreasePeakWithNoiseThreshold.Load(entry, alignment);
    }
    if (result)
    {
        result = increaseDecreasePeakThreshold.Load(entry, alignment);
    }
    if (result)
    {
        result = increaseDecreasePeakWithNoiseThreshold.Load(entry, alignment);
    }
    if (result)
    {
        result = flatThreshold.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, spotlightFlatThresholdMarco, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, spotlightFlatThresholdInfinity, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(region0);
    PARAMETER_INITIALIZE(region1);
    PARAMETER_INITIALIZE(region2);
    PARAMETER_INITIALIZE(region3);
    PARAMETER_INITIALIZE(region4);

    SYMBOL_TABLE_ENTRY_READ(entry, result, region0, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, region1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, region2, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, region3, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, region4, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(prescanNormalLight);
    PARAMETER_INITIALIZE(prescanLowLight);
    PARAMETER_INITIALIZE(finescanNormalLight);
    PARAMETER_INITIALIZE(finescanLowLight);

    result = prescanNormalLight.Load(entry, alignment);
    if (result)
    {
        result = prescanLowLight.Load(entry, alignment);
    }
    if (result)
    {
        result = finescanNormalLight.Load(entry, alignment);
    }
    if (result)
    {
        result = finescanLowLight.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(index);
    PARAMETER_INITIALIZE(actuatorType);
    PARAMETER_INITIALIZE(isHysteresisCompensationNeeded);
    PARAMETER_INITIALIZE(stepIndexPerMicroMeter);
    PARAMETER_INITIALIZE(previewAssistedAFEnable);
    PARAMETER_INITIALIZE(TAFStepTable);
    PARAMETER_INITIALIZE(CAFStepTable);
    PARAMETER_INITIALIZE(software);
    PARAMETER_INITIALIZE(hardware);
    PARAMETER_INITIALIZE(optics);
    PARAMETER_INITIALIZE(frameDelay);
    PARAMETER_INITIALIZE(BVGain);
    PARAMETER_INITIALIZE(ignoreFirstInvalidFrame);


    // Reading Array index from symbol table
    // Do not check result value here because the count value needs to be initialized in this block
    {
        indexCount = 0;
        SYMBOL_TABLE_ENTRY_READ(entry, result, indexCount, alignment)
        constexpr const CHAR* const file {__FILE__};
        constexpr INT32 line {LINE_CONST};
        ParameterFileSymbolTableEntry  pointerEntryCls;
        ParameterFileSymbolTableEntry* const pointerEntry = &pointerEntryCls;
        if (result)
        {
            result = entry->Table->ReadPointerEntry(pointerEntryCls, entry, alignment);
        }

        if (result)
        {
            indexID = pointerEntry->ID;
            DupObjInfo* indexDupInfo = pointerEntry->GetDupObject(indexCount, file, line);
            if (indexDupInfo != nullptr && indexDupInfo->Object != nullptr)
            {
                index = (UINT32*)indexDupInfo->Object;
                if (index == nullptr)
                {
                    if (indexDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "index duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            indexDupInfo->File, indexDupInfo->Line, indexDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "index duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            indexDupInfo->Line, indexDupInfo->RefCount);
                    }
                }
            }

            if (index == nullptr)
            {
                if (result && indexCount > 0)
                {
                    index = pointerEntry->ReadArray<UINT32>(indexCount, alignment);
                    result = index != nullptr;
                }
                if (!result || index == nullptr)
                {
                    if (indexCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate index\n");
                    }
                    indexCount = 0;
                }
            }
        }
        if (index == nullptr)
        {
            indexCount = 0;
        }
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, actuatorType, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, isHysteresisCompensationNeeded, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, stepIndexPerMicroMeter, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, previewAssistedAFEnable, alignment)
    if (result)
    {
        result = TAFStepTable.Load(entry, alignment);
    }
    if (result)
    {
        result = CAFStepTable.Load(entry, alignment);
    }
    if (result)
    {
        result = software.Load(entry, alignment);
    }
    if (result)
    {
        result = hardware.Load(entry, alignment);
    }
    if (result)
    {
        result = optics.Load(entry, alignment);
    }
    if (result)
    {
        result = frameDelay.Load(entry, alignment);
    }
    if (result)
    {
        result = entry->ReadArray(BVGain, 8, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, ignoreFirstInvalidFrame, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(numStepsBetweenStatPoints);
    PARAMETER_INITIALIZE(frameDelayInf);
    PARAMETER_INITIALIZE(frameDelayNorm);
    PARAMETER_INITIALIZE(frameDelayFinal);
    PARAMETER_INITIALIZE(previewAssistedAFEnable);

    SYMBOL_TABLE_ENTRY_READ(entry, result, numStepsBetweenStatPoints, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frameDelayInf, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frameDelayNorm, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, frameDelayFinal, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, previewAssistedAFEnable, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(statisticsSelection);
    PARAMETER_INITIALIZE(face);
    PARAMETER_INITIALIZE(track);
    PARAMETER_INITIALIZE(saliency);
    PARAMETER_INITIALIZE(fullSweep);
    PARAMETER_INITIALIZE(singleSearch);
    PARAMETER_INITIALIZE(weightedWindow);
    PARAMETER_INITIALIZE(exposureCompensation);
    PARAMETER_INITIALIZE(HVFocusValueStatisticWeighting);
    PARAMETER_INITIALIZE(stepBack);

    result = module_version.Load(entry, alignment);
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = afcontrastafelements::ReadEnum_AFStatisticComputationType(entry, statisticsSelection, alignment);
    }
    if (result)
    {
        result = face.Load(entry, alignment);
    }
    if (result)
    {
        result = track.Load(entry, alignment);
    }
    if (result)
    {
        result = saliency.Load(entry, alignment);
    }
    if (result)
    {
        result = fullSweep.Load(entry, alignment);
    }
    if (result)
    {
        result = singleSearch.Load(entry, alignment);
    }
    if (result)
    {
        result = weightedWindow.Load(entry, alignment);
    }
    if (result)
    {
        result = exposureCompensation.Load(entry, alignment);
    }
    if (result)
    {
        result = HVFocusValueStatisticWeighting.Load(entry, alignment);
    }
    if (result)
    {
        result = stepBack.Load(entry, alignment);
    }

    return result;
}

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(revision);


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

    return result;
}

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

    PARAMETER_INITIALIZE(ROIProcessEnable);
    PARAMETER_INITIALIZE(ROIStable);
    PARAMETER_INITIALIZE(ROIChange);

    SYMBOL_TABLE_ENTRY_READ(entry, result, ROIProcessEnable, alignment)
    if (result)
    {
        result = ROIStable.Load(entry, alignment);
    }
    if (result)
    {
        result = ROIChange.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(TrackROIStable);
    PARAMETER_INITIALIZE(TrackROIChange);

    result = TrackROIStable.Load(entry, alignment);
    if (result)
    {
        result = TrackROIChange.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(saliencyROIStable);
    PARAMETER_INITIALIZE(saliencyROIChange);

    result = saliencyROIStable.Load(entry, alignment);
    if (result)
    {
        result = saliencyROIChange.Load(entry, alignment);
    }

    return result;
}

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixAFWeightedWindowReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixAFWeightedWindowReserveType::Unload(ParameterFileSymbolTable* const __table)
{
    AFRegionWeightTable.Unload(__table);
    AFLumaWeightTable.Unload(__table);
    AFFaceWeightTable.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixContrastAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixContrastAFType::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    face.Unload(__table);
    track.Unload(__table);
    saliency.Unload(__table);
    singleSearch.Unload(__table);
    weightedWindow.Unload(__table);
}

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload faceStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixContrastAFType::faceStruct::Unload(ParameterFileSymbolTable* const __table)
{
    ROIStable.Unload(__table);
    ROIChange.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload trackStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixContrastAFType::trackStruct::Unload(ParameterFileSymbolTable* const __table)
{
    TrackROIStable.Unload(__table);
    TrackROIChange.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload saliencyStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixContrastAFType::saliencyStruct::Unload(ParameterFileSymbolTable* const __table)
{
    saliencyROIStable.Unload(__table);
    saliencyROIChange.Unload(__table);
}

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Create module, and return a new object
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ParameterModule* chromatixContrastAFTypeClass::Create(
    ModuleData*    moduleData,
    DefaultModule* const defModule) const
{
    chromatixContrastAFTypeClass* cls = nullptr;

    if (PARAMETER_STRCMP(Type, moduleData->Type) == 0 && Version.Value == moduleData->Version.Value)
    {
        const UINT32 id = moduleData->DuplicateID > 0 ? moduleData->DuplicateID : moduleData->ID;

        ParameterModule* const module = defModule->Find(id);
        if (module != nullptr)
        {
            cls = (chromatixContrastAFTypeClass*)module;
        }
        else
        {
            cls = PARAMETER_NEW chromatixContrastAFTypeClass(GetName(moduleData->Type), moduleData);
            cls->SymbolTableID = id;
            defModule->AddModule((ParameterModule*)cls);
        }
    }
    else if (Version.Value != moduleData->Version.Value)
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatixContrastAFTypeClass, binary version (%lld) does not match source version (%lld)\n",
            moduleData->Version.Value, Version.Value);
    }
    else
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatixContrastAFTypeClass, binary name (%s) does not match source name (%s)\n",
            moduleData->Type, Type);
    }

    return (ParameterModule*)cls;
}

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

    if (!Loaded)
    {
        BYTE const alignment = table->Alignment;
        chromatixContrastAFTypeClass* const cls = this;

        ParameterFileSymbolTableEntry  entryObj;
        ParameterFileSymbolTableEntry* const entry = &entryObj;
        // With EzTune enabled, the unused upper byte of SymbolTableID value can change, so clear it
        result = table->Find(entryObj, SymbolTableID & 0x00ffffff);

        if (!result)
        {
            PARAMETER_LOG_ERROR(entry->SetManager, "chromatixContrastAFTypeClass::LoadModule Failed to find module ID (%d) in Symbol Table\n", SymbolTableID);
        }

        if (result)
        {
            result = cls->Load(entry, alignment);
        }
        Modified++;
        Loaded = true;
    }

    if (!result)
    {
        /// Module failed to fully load, unload it
        UnloadModule();
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload module data
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixContrastAFTypeClass::UnloadModule()
{
    if (Loaded)
    {
        if (Data != nullptr && Data->SymbolTable != nullptr)
        {
            Unload(Data->SymbolTable);
        }
        else
        {
            PARAMETER_LOG_ERROR(Data != nullptr ? Data->SetManager : nullptr, "UnloadModule %s called with nullptr "
                "Data->SymbolTable object\n", Name);
            Unload(nullptr);
        }
        Loaded = false;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// /// Release the ParameterModule object
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixContrastAFTypeClass::Release()
{
    ParameterModule::Release();
}

AFCONTRASTAFELEMENTS_NAMESPACE_END
