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

#include "ioteis_2_6_0.h"
#include "parametersetmanager.h"

IOTEIS_2_6_0_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool warp_map_type::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, "num_ver_x") == 0)
    {
        ParameterUtils::DoubleToString((double)num_ver_x, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "num_ver_y") == 0)
    {
        ParameterUtils::DoubleToString((double)num_ver_y, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "input_width") == 0)
    {
        ParameterUtils::DoubleToString((double)input_width, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "input_height") == 0)
    {
        ParameterUtils::DoubleToString((double)input_height, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "output_width") == 0)
    {
        ParameterUtils::DoubleToString((double)output_width, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "output_height") == 0)
    {
        ParameterUtils::DoubleToString((double)output_height, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "type") == 0)
    {
        ParameterUtils::DoubleToString((double)type, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "mapping_tab") == 0)
    {
        __result = mapping_tab.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool warp_map_type::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, "num_ver_x") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_ver_x = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "num_ver_y") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            num_ver_y = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "input_width") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            input_width = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "input_height") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            input_height = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "output_width") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            output_width = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "output_height") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            output_height = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            type = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "mapping_tab") == 0)
    {
        __result = mapping_tab.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

bool warp_map_type::mapping_tabStruct::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, "mapping") == 0)
    {
        if (__index < 12610)
        {
            ParameterUtils::DoubleToString((double)mapping[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 12610; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)mapping[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

bool LDC_data_type::ldc_r2_lut_tabStruct::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, "ldc_r2_lut") == 0)
    {
        if (__index < 1024)
        {
            ParameterUtils::DoubleToString((double)ldc_r2_lut[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 1024; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)ldc_r2_lut[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

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

    return __result;
}

bool hl_lp_param_type::hl_lp_enable_tabStruct::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, "hl_lp_enable") == 0)
    {
        if (__index < 3)
        {
            ParameterUtils::DoubleToString((double)hl_lp_enable[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 3; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)hl_lp_enable[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

bool hl_lp_param_type::hl_lp_lower_th_tabStruct::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, "hl_lp_lower_th") == 0)
    {
        if (__index < 3)
        {
            ParameterUtils::DoubleToString((double)hl_lp_lower_th[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 3; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)hl_lp_lower_th[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

bool hl_lp_param_type::hl_lp_upper_th_tabStruct::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, "hl_lp_upper_th") == 0)
    {
        if (__index < 3)
        {
            ParameterUtils::DoubleToString((double)hl_lp_upper_th[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 3; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)hl_lp_upper_th[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

bool eis_strength_type::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, "temporal_filter") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            temporal_filter = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "number_of_entries") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            number_of_entries = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "eis_strength_entries") == 0)
    {
        if (__index < eis_strength_entriesCount)
        {
            __result = eis_strength_entries[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool filter_param_type::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, "smoothing_index_pitch") == 0)
    {
        ParameterUtils::DoubleToString((double)smoothing_index_pitch, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_index_yaw") == 0)
    {
        ParameterUtils::DoubleToString((double)smoothing_index_yaw, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_index_roll") == 0)
    {
        ParameterUtils::DoubleToString((double)smoothing_index_roll, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_additional_k") == 0)
    {
        ParameterUtils::DoubleToString((double)smoothing_additional_k, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_lut_1st_order_small_motion") == 0)
    {
        ParameterUtils::DoubleToString((double)smoothing_lut_1st_order_small_motion, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_lut_2nd_order_small_motion") == 0)
    {
        ParameterUtils::DoubleToString((double)smoothing_lut_2nd_order_small_motion, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_lut_1st_order_large_motion") == 0)
    {
        ParameterUtils::DoubleToString((double)smoothing_lut_1st_order_large_motion, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_lut_2nd_order_large_motion") == 0)
    {
        ParameterUtils::DoubleToString((double)smoothing_lut_2nd_order_large_motion, __value, __size);
        __result = true;
    }

    return __result;
}

bool filter_param_type::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, "smoothing_index_pitch") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smoothing_index_pitch = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_index_yaw") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smoothing_index_yaw = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_index_roll") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smoothing_index_roll = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_additional_k") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smoothing_additional_k = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_lut_1st_order_small_motion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smoothing_lut_1st_order_small_motion = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_lut_2nd_order_small_motion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smoothing_lut_2nd_order_small_motion = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_lut_1st_order_large_motion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smoothing_lut_1st_order_large_motion = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "smoothing_lut_2nd_order_large_motion") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            smoothing_lut_2nd_order_large_motion = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

    return __result;
}

bool mvDGTC_tuning_type::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, "filter_param") == 0)
    {
        __result = filter_param.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "eis_strength") == 0)
    {
        __result = eis_strength.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "horizon_leveling_en") == 0)
    {
        ParameterUtils::DoubleToString((double)horizon_leveling_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "ext_pose_en") == 0)
    {
        ParameterUtils::DoubleToString((double)ext_pose_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "q_6degree_tab") == 0)
    {
        __result = q_6degree_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "pipeline_config_mode") == 0)
    {
        ParameterUtils::DoubleToString((double)pipeline_config_mode, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "small_number") == 0)
    {
        ParameterUtils::DoubleToString((double)small_number, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "big_number") == 0)
    {
        ParameterUtils::DoubleToString((double)big_number, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "prefusion_small_number") == 0)
    {
        ParameterUtils::DoubleToString((double)prefusion_small_number, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "prefusion_big_number") == 0)
    {
        ParameterUtils::DoubleToString((double)prefusion_big_number, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "running_phase_small_number") == 0)
    {
        ParameterUtils::DoubleToString((double)running_phase_small_number, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "running_phase_big_number") == 0)
    {
        ParameterUtils::DoubleToString((double)running_phase_big_number, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pre_take_off_accel_std") == 0)
    {
        ParameterUtils::DoubleToString((double)pre_take_off_accel_std, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pre_take_off_gyro_std") == 0)
    {
        ParameterUtils::DoubleToString((double)pre_take_off_gyro_std, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pre_take_off_revert_length") == 0)
    {
        ParameterUtils::DoubleToString((double)pre_take_off_revert_length, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "inc_number") == 0)
    {
        ParameterUtils::DoubleToString((double)inc_number, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "window_size") == 0)
    {
        ParameterUtils::DoubleToString((double)window_size, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aero_norm_lower_bound") == 0)
    {
        ParameterUtils::DoubleToString((double)aero_norm_lower_bound, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aero_norm_upper_bound") == 0)
    {
        ParameterUtils::DoubleToString((double)aero_norm_upper_bound, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aero_norm_diff_threshold") == 0)
    {
        ParameterUtils::DoubleToString((double)aero_norm_diff_threshold, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aero_iterative_en") == 0)
    {
        ParameterUtils::DoubleToString((double)aero_iterative_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aero_dynamic_en") == 0)
    {
        ParameterUtils::DoubleToString((double)aero_dynamic_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "sensor_fusion_type") == 0)
    {
        ParameterUtils::DoubleToString((double)sensor_fusion_type, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "hl_lp_tuning_parameters") == 0)
    {
        __result = hl_lp_tuning_parameters.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "pitch_offset") == 0)
    {
        ParameterUtils::DoubleToString((double)pitch_offset, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "check_switch_point_en") == 0)
    {
        ParameterUtils::DoubleToString((double)check_switch_point_en, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "pts_gap_between_cimu_fimu") == 0)
    {
        ParameterUtils::DoubleToString((double)pts_gap_between_cimu_fimu, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool mvDGTC_tuning_type::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, "filter_param") == 0)
    {
        __result = filter_param.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "eis_strength") == 0)
    {
        __result = eis_strength.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "horizon_leveling_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            horizon_leveling_en = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "ext_pose_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            ext_pose_en = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "q_6degree_tab") == 0)
    {
        __result = q_6degree_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "pipeline_config_mode") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pipeline_config_mode = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "small_number") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            small_number = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "big_number") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            big_number = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "prefusion_small_number") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            prefusion_small_number = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "prefusion_big_number") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            prefusion_big_number = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "running_phase_small_number") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            running_phase_small_number = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "running_phase_big_number") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            running_phase_big_number = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pre_take_off_accel_std") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pre_take_off_accel_std = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pre_take_off_gyro_std") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pre_take_off_gyro_std = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pre_take_off_revert_length") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pre_take_off_revert_length = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "inc_number") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            inc_number = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "window_size") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            window_size = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aero_norm_lower_bound") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aero_norm_lower_bound = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aero_norm_upper_bound") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aero_norm_upper_bound = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aero_norm_diff_threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aero_norm_diff_threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aero_iterative_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aero_iterative_en = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aero_dynamic_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aero_dynamic_en = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "sensor_fusion_type") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            sensor_fusion_type = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "hl_lp_tuning_parameters") == 0)
    {
        __result = hl_lp_tuning_parameters.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "pitch_offset") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pitch_offset = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "check_switch_point_en") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            check_switch_point_en = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "pts_gap_between_cimu_fimu") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pts_gap_between_cimu_fimu = (UINT32)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool mvDGTC_tuning_type::q_6degree_tabStruct::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, "q_6degree") == 0)
    {
        if (__index < 4)
        {
            ParameterUtils::DoubleToString((double)q_6degree[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 4; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)q_6degree[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

bool mvDGTC_imu_temp_calib_type::drift_table_tabStruct::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)
    {
        if (__index < 18)
        {
            ParameterUtils::DoubleToString((double)value[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 18; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)value[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool mvDGTC_imu_temp_calib_type::drift_table_tabStruct::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)
    {
        if (__index < 18)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                value[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool mvDGTC_imu_temp_calib_type::drift_table_tabStruct::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, true, false, 18));
    }

    return __result;
}

bool mvDGTC_imu_temp_calib_type::drift_temp_knee_tabStruct::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)
    {
        if (__index < 6)
        {
            ParameterUtils::DoubleToString((double)value[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 6; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)value[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

bool mvDGTC_imu_temp_calib_type::drift_temp_knee_tabStruct::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)
    {
        if (__index < 6)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                value[__index] = (float)dblValue; 
            }
        }
        else
        {
            SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __pos = 0;

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

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

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

    return __result;
}

bool mvDGTC_imu_temp_calib_type::drift_temp_knee_tabStruct::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, true, false, 6));
    }

    return __result;
}

bool mvDGTC_imu_calib_type::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, "acc_unit") == 0)
    {
        ParameterUtils::DoubleToString((double)acc_unit, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyro_unit") == 0)
    {
        ParameterUtils::DoubleToString((double)gyro_unit, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyro_constant_delay_off_pts_in_us") == 0)
    {
        ParameterUtils::DoubleToString((double)gyro_constant_delay_off_pts_in_us, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "accel_constant_delay_off_pts_in_us") == 0)
    {
        ParameterUtils::DoubleToString((double)accel_constant_delay_off_pts_in_us, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "gyro_rotation_tab") == 0)
    {
        __result = gyro_rotation_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "accel_rotation_tab") == 0)
    {
        __result = accel_rotation_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "ext_rotation_tab") == 0)
    {
        __result = ext_rotation_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "aux_gyro_rotation_tab") == 0)
    {
        __result = aux_gyro_rotation_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "aux_accel_rotation_tab") == 0)
    {
        __result = aux_accel_rotation_tab.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "imu_temp_calib") == 0)
    {
        __result = imu_temp_calib.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool mvDGTC_imu_calib_type::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, "acc_unit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            acc_unit = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyro_unit") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gyro_unit = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyro_constant_delay_off_pts_in_us") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            gyro_constant_delay_off_pts_in_us = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "accel_constant_delay_off_pts_in_us") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            accel_constant_delay_off_pts_in_us = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "gyro_rotation_tab") == 0)
    {
        __result = gyro_rotation_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "accel_rotation_tab") == 0)
    {
        __result = accel_rotation_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "ext_rotation_tab") == 0)
    {
        __result = ext_rotation_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "aux_gyro_rotation_tab") == 0)
    {
        __result = aux_gyro_rotation_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "aux_accel_rotation_tab") == 0)
    {
        __result = aux_accel_rotation_tab.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "imu_temp_calib") == 0)
    {
        __result = imu_temp_calib.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool mvDGTC_imu_calib_type::gyro_rotation_tabStruct::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, "rotation") == 0)
    {
        if (__index < 9)
        {
            ParameterUtils::DoubleToString((double)rotation[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 9; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)rotation[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

bool mvDGTC_imu_calib_type::accel_rotation_tabStruct::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, "rotation") == 0)
    {
        if (__index < 9)
        {
            ParameterUtils::DoubleToString((double)rotation[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 9; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)rotation[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

bool mvDGTC_imu_calib_type::ext_rotation_tabStruct::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, "rotation") == 0)
    {
        if (__index < 9)
        {
            ParameterUtils::DoubleToString((double)rotation[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 9; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)rotation[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

bool mvDGTC_imu_calib_type::aux_gyro_rotation_tabStruct::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, "rotation") == 0)
    {
        if (__index < 9)
        {
            ParameterUtils::DoubleToString((double)rotation[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 9; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)rotation[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

bool mvDGTC_imu_calib_type::aux_accel_rotation_tabStruct::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, "rotation") == 0)
    {
        if (__index < 9)
        {
            ParameterUtils::DoubleToString((double)rotation[__index], __value, __size);
            __result = true;
        }
        else
        {
            SIZE_T __valuePos = 0;
            for (UINT32 i = 0; i < 9; i++)
            {
                if (i > 0)
                {
                    PARAMETER_STRCAT(__value, __size, ",");
                    __valuePos = PARAMETER_STRLEN(__value);
                }
                ParameterUtils::DoubleToString((double)rotation[i], &__value[__valuePos], (INT32)(__size - __valuePos));
            }
            __result = true;
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

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

    return __result;
}

bool DGTC_data_type::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, "imu_calib") == 0)
    {
        __result = imu_calib.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "pixel_size_in_um") == 0)
    {
        ParameterUtils::DoubleToString((double)pixel_size_in_um, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "focal_length_in_mm") == 0)
    {
        ParameterUtils::DoubleToString((double)focal_length_in_mm, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "imu_data_sampling_rate") == 0)
    {
        ParameterUtils::DoubleToString((double)imu_data_sampling_rate, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "accel_sampling_rate") == 0)
    {
        ParameterUtils::DoubleToString((double)accel_sampling_rate, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aux_gyro_sampling_rate") == 0)
    {
        ParameterUtils::DoubleToString((double)aux_gyro_sampling_rate, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "aux_accel_sampling_rate") == 0)
    {
        ParameterUtils::DoubleToString((double)aux_accel_sampling_rate, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "fbis_margin") == 0)
    {
        ParameterUtils::DoubleToString((double)fbis_margin, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "rsc_margin") == 0)
    {
        ParameterUtils::DoubleToString((double)rsc_margin, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "tuning_param") == 0)
    {
        __result = tuning_param.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool DGTC_data_type::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, "imu_calib") == 0)
    {
        __result = imu_calib.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "pixel_size_in_um") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            pixel_size_in_um = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "focal_length_in_mm") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            focal_length_in_mm = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "imu_data_sampling_rate") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            imu_data_sampling_rate = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "accel_sampling_rate") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            accel_sampling_rate = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aux_gyro_sampling_rate") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aux_gyro_sampling_rate = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "aux_accel_sampling_rate") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            aux_accel_sampling_rate = (UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "fbis_margin") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            fbis_margin = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "rsc_margin") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            rsc_margin = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "tuning_param") == 0)
    {
        __result = tuning_param.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable_section") == 0)
    {
        __result = enable_section.GetValue(&__path[__pos], __value, __size);
    }
    else 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, "DGTC") == 0)
    {
        __result = DGTC.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "LDC") == 0)
    {
        __result = LDC.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "Custom") == 0)
    {
        __result = Custom.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable_section") == 0)
    {
        __result = enable_section.SetValue(&__path[__pos], __value);
    }
    else 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, "DGTC") == 0)
    {
        __result = DGTC.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "LDC") == 0)
    {
        __result = LDC.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "Custom") == 0)
    {
        __result = Custom.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

    // 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);
    }

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

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

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

    return __result;
}

bool ioteis26Type::enable_sectionStruct::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, "eis_enable") == 0)
    {
        ParameterUtils::DoubleToString((double)eis_enable, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool ioteis26Type::enable_sectionStruct::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, "eis_enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            eis_enable = (globalelements::enable_flag_type)dblValue; 
        }
    }

    return __result;
}

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

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

    return __result;
}

bool ioteis26Type::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 ioteis26Type::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 ioteis26Type::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 ioteis26Type::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 ioteis26Type::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 ioteis26Type::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;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ioteis26TypeClass::ioteis26TypeClass(
    const CHAR* const name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(enable_section);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(DGTC);
    PARAMETER_INITIALIZE(LDC);
    PARAMETER_INITIALIZE(Custom);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ioteis26TypeClass::ioteis26TypeClass(
    const CHAR* const name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(enable_section);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(DGTC);
    PARAMETER_INITIALIZE(LDC);
    PARAMETER_INITIALIZE(Custom);
}

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

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

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

    PARAMETER_INITIALIZE(num_ver_x);
    PARAMETER_INITIALIZE(num_ver_y);
    PARAMETER_INITIALIZE(input_width);
    PARAMETER_INITIALIZE(input_height);
    PARAMETER_INITIALIZE(output_width);
    PARAMETER_INITIALIZE(output_height);
    PARAMETER_INITIALIZE(type);
    PARAMETER_INITIALIZE(mapping_tab);

    SYMBOL_TABLE_ENTRY_READ(entry, result, num_ver_x, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, num_ver_y, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, input_width, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, input_height, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, output_width, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, output_height, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, type, alignment)
    if (result)
    {
        result = mapping_tab.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(mapping);

    result = entry->ReadArray(mapping, 12610, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(custom_mesh);


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

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

    return result;
}

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

    PARAMETER_INITIALIZE(ldc_mesh);
    PARAMETER_INITIALIZE(ldc_r2_lut_size);
    PARAMETER_INITIALIZE(ldc_r2_lut_tab);

    result = ldc_mesh.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, ldc_r2_lut_size, alignment)
    if (result)
    {
        result = ldc_r2_lut_tab.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(ldc_r2_lut);

    result = entry->ReadArray(ldc_r2_lut, 1024, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(hl_lp_enable_tab);
    PARAMETER_INITIALIZE(hl_lp_lower_th_tab);
    PARAMETER_INITIALIZE(hl_lp_upper_th_tab);
    PARAMETER_INITIALIZE(hl_lp_enable_yaw);

    result = hl_lp_enable_tab.Load(entry, alignment);
    if (result)
    {
        result = hl_lp_lower_th_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = hl_lp_upper_th_tab.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, hl_lp_enable_yaw, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(hl_lp_enable);

    result = entry->ReadArray(hl_lp_enable, 3, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(hl_lp_lower_th);

    result = entry->ReadArray(hl_lp_lower_th, 3, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(hl_lp_upper_th);

    result = entry->ReadArray(hl_lp_upper_th, 3, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(trigger_start);
    PARAMETER_INITIALIZE(trigger_end);
    PARAMETER_INITIALIZE(strength);

    SYMBOL_TABLE_ENTRY_READ(entry, result, trigger_start, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, trigger_end, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, strength, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(temporal_filter);
    PARAMETER_INITIALIZE(number_of_entries);
    PARAMETER_INITIALIZE(eis_strength_entries);

    SYMBOL_TABLE_ENTRY_READ(entry, result, temporal_filter, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, number_of_entries, alignment)

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(smoothing_index_pitch);
    PARAMETER_INITIALIZE(smoothing_index_yaw);
    PARAMETER_INITIALIZE(smoothing_index_roll);
    PARAMETER_INITIALIZE(smoothing_additional_k);
    PARAMETER_INITIALIZE(smoothing_lut_1st_order_small_motion);
    PARAMETER_INITIALIZE(smoothing_lut_2nd_order_small_motion);
    PARAMETER_INITIALIZE(smoothing_lut_1st_order_large_motion);
    PARAMETER_INITIALIZE(smoothing_lut_2nd_order_large_motion);

    SYMBOL_TABLE_ENTRY_READ(entry, result, smoothing_index_pitch, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, smoothing_index_yaw, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, smoothing_index_roll, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, smoothing_additional_k, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, smoothing_lut_1st_order_small_motion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, smoothing_lut_2nd_order_small_motion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, smoothing_lut_1st_order_large_motion, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, smoothing_lut_2nd_order_large_motion, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(filter_param);
    PARAMETER_INITIALIZE(eis_strength);
    PARAMETER_INITIALIZE(horizon_leveling_en);
    PARAMETER_INITIALIZE(ext_pose_en);
    PARAMETER_INITIALIZE(q_6degree_tab);
    PARAMETER_INITIALIZE(pipeline_config_mode);
    PARAMETER_INITIALIZE(small_number);
    PARAMETER_INITIALIZE(big_number);
    PARAMETER_INITIALIZE(prefusion_small_number);
    PARAMETER_INITIALIZE(prefusion_big_number);
    PARAMETER_INITIALIZE(running_phase_small_number);
    PARAMETER_INITIALIZE(running_phase_big_number);
    PARAMETER_INITIALIZE(pre_take_off_accel_std);
    PARAMETER_INITIALIZE(pre_take_off_gyro_std);
    PARAMETER_INITIALIZE(pre_take_off_revert_length);
    PARAMETER_INITIALIZE(inc_number);
    PARAMETER_INITIALIZE(window_size);
    PARAMETER_INITIALIZE(aero_norm_lower_bound);
    PARAMETER_INITIALIZE(aero_norm_upper_bound);
    PARAMETER_INITIALIZE(aero_norm_diff_threshold);
    PARAMETER_INITIALIZE(aero_iterative_en);
    PARAMETER_INITIALIZE(aero_dynamic_en);
    PARAMETER_INITIALIZE(sensor_fusion_type);
    PARAMETER_INITIALIZE(hl_lp_tuning_parameters);
    PARAMETER_INITIALIZE(pitch_offset);
    PARAMETER_INITIALIZE(check_switch_point_en);
    PARAMETER_INITIALIZE(pts_gap_between_cimu_fimu);

    result = filter_param.Load(entry, alignment);
    if (result)
    {
        result = eis_strength.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, horizon_leveling_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, ext_pose_en, alignment)
    if (result)
    {
        result = q_6degree_tab.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, pipeline_config_mode, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, small_number, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, big_number, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, prefusion_small_number, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, prefusion_big_number, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, running_phase_small_number, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, running_phase_big_number, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pre_take_off_accel_std, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pre_take_off_gyro_std, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pre_take_off_revert_length, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, inc_number, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, window_size, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, aero_norm_lower_bound, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, aero_norm_upper_bound, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, aero_norm_diff_threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, aero_iterative_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, aero_dynamic_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, sensor_fusion_type, alignment)
    if (result)
    {
        result = hl_lp_tuning_parameters.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, pitch_offset, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, check_switch_point_en, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, pts_gap_between_cimu_fimu, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(q_6degree);

    result = entry->ReadArray(q_6degree, 4, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(tmpt_bias_comp_en);
    PARAMETER_INITIALIZE(drift_table_tab);
    PARAMETER_INITIALIZE(drift_temp_knee_tab);

    SYMBOL_TABLE_ENTRY_READ(entry, result, tmpt_bias_comp_en, alignment)
    if (result)
    {
        result = drift_table_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = drift_temp_knee_tab.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(value);

    result = entry->ReadArray(value, 18, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(value);

    result = entry->ReadArray(value, 6, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(acc_unit);
    PARAMETER_INITIALIZE(gyro_unit);
    PARAMETER_INITIALIZE(gyro_constant_delay_off_pts_in_us);
    PARAMETER_INITIALIZE(accel_constant_delay_off_pts_in_us);
    PARAMETER_INITIALIZE(gyro_rotation_tab);
    PARAMETER_INITIALIZE(accel_rotation_tab);
    PARAMETER_INITIALIZE(ext_rotation_tab);
    PARAMETER_INITIALIZE(aux_gyro_rotation_tab);
    PARAMETER_INITIALIZE(aux_accel_rotation_tab);
    PARAMETER_INITIALIZE(imu_temp_calib);

    SYMBOL_TABLE_ENTRY_READ(entry, result, acc_unit, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyro_unit, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, gyro_constant_delay_off_pts_in_us, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, accel_constant_delay_off_pts_in_us, alignment)
    if (result)
    {
        result = gyro_rotation_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = accel_rotation_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = ext_rotation_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = aux_gyro_rotation_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = aux_accel_rotation_tab.Load(entry, alignment);
    }
    if (result)
    {
        result = imu_temp_calib.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(rotation);

    result = entry->ReadArray(rotation, 9, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(rotation);

    result = entry->ReadArray(rotation, 9, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(rotation);

    result = entry->ReadArray(rotation, 9, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(rotation);

    result = entry->ReadArray(rotation, 9, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(rotation);

    result = entry->ReadArray(rotation, 9, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(imu_calib);
    PARAMETER_INITIALIZE(pixel_size_in_um);
    PARAMETER_INITIALIZE(focal_length_in_mm);
    PARAMETER_INITIALIZE(imu_data_sampling_rate);
    PARAMETER_INITIALIZE(accel_sampling_rate);
    PARAMETER_INITIALIZE(aux_gyro_sampling_rate);
    PARAMETER_INITIALIZE(aux_accel_sampling_rate);
    PARAMETER_INITIALIZE(fbis_margin);
    PARAMETER_INITIALIZE(rsc_margin);
    PARAMETER_INITIALIZE(tuning_param);

    result = imu_calib.Load(entry, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, pixel_size_in_um, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, focal_length_in_mm, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, imu_data_sampling_rate, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, accel_sampling_rate, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, aux_gyro_sampling_rate, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, aux_accel_sampling_rate, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, fbis_margin, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, rsc_margin, alignment)
    if (result)
    {
        result = tuning_param.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enable_section);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(parameter_version);
    PARAMETER_INITIALIZE(DGTC);
    PARAMETER_INITIALIZE(LDC);
    PARAMETER_INITIALIZE(Custom);

    result = enable_section.Load(entry, alignment);
    if (result)
    {
        result = module_version.Load(entry, alignment);
    }
    if (result)
    {
        result = parameter_version.Load(entry, alignment);
    }
    if (result)
    {
        result = DGTC.Load(entry, alignment);
    }
    if (result)
    {
        result = LDC.Load(entry, alignment);
    }
    if (result)
    {
        result = Custom.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(eis_enable);

    SYMBOL_TABLE_ENTRY_READ(entry, result, eis_enable, alignment)

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load module_versionStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ioteis26Type::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 ioteis26Type::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;
}

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload mvDGTC_tuning_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mvDGTC_tuning_type::Unload(ParameterFileSymbolTable* const __table)
{
    eis_strength.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload DGTC_data_type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void DGTC_data_type::Unload(ParameterFileSymbolTable* const __table)
{
    tuning_param.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload ioteis26Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ioteis26Type::Unload(ParameterFileSymbolTable* const __table)
{
    parameter_version.Unload(__table);
    DGTC.Unload(__table);
    Custom.Unload(__table);
}

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

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

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

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

    return (ParameterModule*)cls;
}

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

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

IOTEIS_2_6_0_NAMESPACE_END
