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

#include "afglobalelements.h"
#include "parametersetmanager.h"

AFGLOBALELEMENTS_NAMESPACE_BEGIN

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

    return __result;
}

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

    return __result;
}

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

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

    // 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 AFWeightLookupTableType::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, "entries") == 0)
    {
        if (__index < entriesCount)
        {
            __result = entries[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool expIdxTypeSensitivityModifier::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, "index") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            index = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "value") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            value = (INT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool chromatixROISizeBasedGridConfig::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, "roiSize") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            roiSize = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numHRegions") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numHRegions = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "numVRegions") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            numVRegions = (UINT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPEDEFAULT):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPEDEFAULT;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPEFACE):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPEFACE;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPETOUCH):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPETOUCH;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPETRACK):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPETRACK;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPESALIENT):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPESALIENT;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPEEYE):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPEEYE;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPETORSO):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPETORSO;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPEHEAD):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPEHEAD;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPERES1):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPERES1;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPERES2):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPERES2;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPERES3):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPERES3;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeROIEnum::ROITYPEMAX):
            enumValue = AFTriggerCtrlTypeROIEnum::ROITYPEMAX;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AFTriggerCtrlTypeROIEnum", 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_AFTriggerCtrlTypeSceneEnum(
    ParameterFileSymbolTableEntry* const entry,
    AFTriggerCtrlTypeSceneEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AFTriggerCtrlTypeSceneEnum::SceneTypeSpotlight):
            enumValue = AFTriggerCtrlTypeSceneEnum::SceneTypeSpotlight;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeSceneEnum::SceneTypeRes1):
            enumValue = AFTriggerCtrlTypeSceneEnum::SceneTypeRes1;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeSceneEnum::SceneTypeRes2):
            enumValue = AFTriggerCtrlTypeSceneEnum::SceneTypeRes2;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeSceneEnum::SceneTypeRes3):
            enumValue = AFTriggerCtrlTypeSceneEnum::SceneTypeRes3;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeSceneEnum::SceneTypeRes4):
            enumValue = AFTriggerCtrlTypeSceneEnum::SceneTypeRes4;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeSceneEnum::SceneTypeRes5):
            enumValue = AFTriggerCtrlTypeSceneEnum::SceneTypeRes5;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeSceneEnum::SceneTypeResMAX):
            enumValue = AFTriggerCtrlTypeSceneEnum::SceneTypeResMAX;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AFTriggerCtrlTypeSceneEnum", 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_AFTriggerCtrlTypeWindowEnum(
    ParameterFileSymbolTableEntry* const entry,
    AFTriggerCtrlTypeWindowEnum& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(AFTriggerCtrlTypeWindowEnum::WindowTypeSingle):
            enumValue = AFTriggerCtrlTypeWindowEnum::WindowTypeSingle;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeWindowEnum::WindowTypeMW):
            enumValue = AFTriggerCtrlTypeWindowEnum::WindowTypeMW;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeWindowEnum::WindowTypePeripheral):
            enumValue = AFTriggerCtrlTypeWindowEnum::WindowTypePeripheral;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeWindowEnum::WindowTypeRes1):
            enumValue = AFTriggerCtrlTypeWindowEnum::WindowTypeRes1;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeWindowEnum::WindowTypeRes2):
            enumValue = AFTriggerCtrlTypeWindowEnum::WindowTypeRes2;
            result    = true;
            break;
        case static_cast<UINT32>(AFTriggerCtrlTypeWindowEnum::WindowTypeResMax):
            enumValue = AFTriggerCtrlTypeWindowEnum::WindowTypeResMax;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to AFTriggerCtrlTypeWindowEnum", 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_chromatixAFMultiROIType(
    ParameterFileSymbolTableEntry* const entry,
    chromatixAFMultiROIType& enumValue,
    BYTE const alignment)
{
    bool result {false};

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeFace):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeFace;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeEye):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeEye;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeTorso):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeTorso;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeHead):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeHead;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeCenterGrid):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeCenterGrid;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeALL):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeALL;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeRes1):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeRes1;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeRes2):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeRes2;
            result    = true;
            break;
        case static_cast<UINT32>(chromatixAFMultiROIType::AFMultiROITypeRes3):
            enumValue = chromatixAFMultiROIType::AFMultiROITypeRes3;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to chromatixAFMultiROIType", uintValue);
            break;
        }
    }
    return result;
}



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

    PARAMETER_INITIALIZE(value);
    PARAMETER_INITIALIZE(weight);

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

    return result;
}

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

    PARAMETER_INITIALIZE(entries);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(value);

    result = afglobalelements::ReadEnum_AFTriggerCtrlTypeROIEnum(entry, type, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(value);

    result = afglobalelements::ReadEnum_AFTriggerCtrlTypeSceneEnum(entry, type, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(value);

    result = afglobalelements::ReadEnum_AFTriggerCtrlTypeWindowEnum(entry, type, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(zoomRatio);
    PARAMETER_INITIALIZE(value);

    SYMBOL_TABLE_ENTRY_READ(entry, result, zoomRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(roiSizeRatio);
    PARAMETER_INITIALIZE(value);

    SYMBOL_TABLE_ENTRY_READ(entry, result, roiSizeRatio, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(gain);
    PARAMETER_INITIALIZE(value);

    SYMBOL_TABLE_ENTRY_READ(entry, result, gain, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(index);
    PARAMETER_INITIALIZE(value);

    SYMBOL_TABLE_ENTRY_READ(entry, result, index, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, value, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(HScale);
    PARAMETER_INITIALIZE(VScale);

    SYMBOL_TABLE_ENTRY_READ(entry, result, HScale, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, VScale, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(roiSize);
    PARAMETER_INITIALIZE(numHRegions);
    PARAMETER_INITIALIZE(numVRegions);

    SYMBOL_TABLE_ENTRY_READ(entry, result, roiSize, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numHRegions, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, numVRegions, alignment)

    return result;
}

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