////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// All rights reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: Parameter Parser V7.4.1 (8cca6579792b9fcef3bc725ff070c5ec453c7c85)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

#include "moddualcamsyncv1.h"
#include "parametersetmanager.h"

MODDUALCAMSYNCV1_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SetValue/GetValue Functions
/// Gets or sets the requested value
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool resultBlenderType::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, "enableResultBlenderFlag") == 0)
    {
        ParameterUtils::DoubleToString((double)enableResultBlenderFlag, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BFWsConfidenceLevel") == 0)
    {
        if (__index < BFWsConfidenceLevelCount)
        {
            __result = BFWsConfidenceLevel[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "BGWsConfidenceLevel") == 0)
    {
        if (__index < BGWsConfidenceLevelCount)
        {
            __result = BGWsConfidenceLevel[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "ColorMappingConfidenceLevel") == 0)
    {
        if (__index < ColorMappingConfidenceLevelCount)
        {
            __result = ColorMappingConfidenceLevel[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool resultBlenderType::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, "enableResultBlenderFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableResultBlenderFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BFWsConfidenceLevel") == 0)
    {
        if (__index < BFWsConfidenceLevelCount)
        {
            __result = BFWsConfidenceLevel[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "BGWsConfidenceLevel") == 0)
    {
        if (__index < BGWsConfidenceLevelCount)
        {
            __result = BGWsConfidenceLevel[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "ColorMappingConfidenceLevel") == 0)
    {
        if (__index < ColorMappingConfidenceLevelCount)
        {
            __result = ColorMappingConfidenceLevel[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

bool modBayerFloatingWindowsSynctype::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, "enableBFWSyncFlag") == 0)
    {
        ParameterUtils::DoubleToString((double)enableBFWSyncFlag, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BayerFloatingWindowsList") == 0)
    {
        if (__index < BayerFloatingWindowsListCount)
        {
            __result = BayerFloatingWindowsList[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "BFWsOutlierTolerance") == 0)
    {
        ParameterUtils::DoubleToString((double)BFWsOutlierTolerance, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BFWsOutlierDistanceWeightTrigger") == 0)
    {
        __result = BFWsOutlierDistanceWeightTrigger.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool modBayerFloatingWindowsSynctype::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, "enableBFWSyncFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableBFWSyncFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BayerFloatingWindowsList") == 0)
    {
        if (__index < BayerFloatingWindowsListCount)
        {
            __result = BayerFloatingWindowsList[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "BFWsOutlierTolerance") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            BFWsOutlierTolerance = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BFWsOutlierDistanceWeightTrigger") == 0)
    {
        __result = BFWsOutlierDistanceWeightTrigger.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

bool modBayerGridWindowsSynctype::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, "enableBGWsFlag") == 0)
    {
        ParameterUtils::DoubleToString((double)enableBGWsFlag, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableROIAlignmentEveryFrameFlag") == 0)
    {
        ParameterUtils::DoubleToString((double)enableROIAlignmentEveryFrameFlag, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "enableDynamicAlignmentFlag") == 0)
    {
        ParameterUtils::DoubleToString((double)enableDynamicAlignmentFlag, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BayerGridWindowsList") == 0)
    {
        if (__index < BayerGridWindowsListCount)
        {
            __result = BayerGridWindowsList[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "templateMatchingROInumber") == 0)
    {
        ParameterUtils::DoubleToString((double)templateMatchingROInumber, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BGWsOutlierTolerance") == 0)
    {
        ParameterUtils::DoubleToString((double)BGWsOutlierTolerance, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "BGWsOutlierDistanceWeightTrigger") == 0)
    {
        __result = BGWsOutlierDistanceWeightTrigger.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "scoreThres") == 0)
    {
        ParameterUtils::DoubleToString((double)scoreThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "scoreImproveThres") == 0)
    {
        ParameterUtils::DoubleToString((double)scoreImproveThres, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "offsetThres") == 0)
    {
        ParameterUtils::DoubleToString((double)offsetThres, __value, __size, 0);
        __result = true;
    }

    return __result;
}

bool modBayerGridWindowsSynctype::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, "enableBGWsFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableBGWsFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableROIAlignmentEveryFrameFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableROIAlignmentEveryFrameFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableDynamicAlignmentFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableDynamicAlignmentFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BayerGridWindowsList") == 0)
    {
        if (__index < BayerGridWindowsListCount)
        {
            __result = BayerGridWindowsList[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "templateMatchingROInumber") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            templateMatchingROInumber = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BGWsOutlierTolerance") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            BGWsOutlierTolerance = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "BGWsOutlierDistanceWeightTrigger") == 0)
    {
        __result = BGWsOutlierDistanceWeightTrigger.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "scoreThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            scoreThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "scoreImproveThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            scoreImproveThres = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "offsetThres") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            offsetThres = (UINT8)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "threshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            threshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "res1") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            res1 = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "res2") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            res2 = (float)dblValue; 
        }
    }

    return __result;
}

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

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

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

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

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

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

    return __result;
}

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

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

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

    return __result;
}

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

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

    if (PARAMETER_STRCMP(__name, "VertexIdx") == 0)
    {
        if (__index < VertexIdxFixedCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                VertexIdx[__index] = (INT32)dblValue; 
            }
        }
        else
        {
            const SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __valuePos = 0;

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    VertexIdx[__index] = (INT32)dblValue; 
                }
                __index++;
            }
            __result = true;
        }
    }
    else if (PARAMETER_STRCMP(__name, "sideIdx") == 0)
    {
        if (__index < sideIdxFixedCount)
        {
            const double dblValue = ParameterUtils::StringToDouble(__value, __result);
            if (__result)
            {
                sideIdx[__index] = (INT32)dblValue; 
            }
        }
        else
        {
            const SIZE_T __valueLen = PARAMETER_STRLEN(__value);
            UINT32 __valuePos = 0;

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

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

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

    return __result;
}

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

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

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

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

    return __result;
}

bool modmultiCamSyncadvFCMTriglData::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, "TriglData") == 0)
    {
        if (__index < TriglDataCount)
        {
            __result = TriglData[__index].GetValue(&__path[__pos], __value, __size);
        }
    }
    else if (PARAMETER_STRCMP(__name, "vertexData") == 0)
    {
        if (__index < vertexDataCount)
        {
            __result = vertexData[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool modmultiCamSyncadvFCMTriglData::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, "TriglData") == 0)
    {
        if (__index < TriglDataCount)
        {
            __result = TriglData[__index].SetValue(&__path[__pos], __value);
        }
    }
    else if (PARAMETER_STRCMP(__name, "vertexData") == 0)
    {
        if (__index < vertexDataCount)
        {
            __result = vertexData[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

bool modmulticamSyncadvFCMType::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, "triggerPt") == 0)
    {
        __result = triggerPt.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool modmulticamSyncadvFCMType::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, "triggerPt") == 0)
    {
        __result = triggerPt.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool modmulticamExtSynctype::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, "enableFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableAlwaysFollowFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableAlwaysFollowFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "enableInstantFCMStartFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableInstantFCMStartFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "advFCMData") == 0)
    {
        __result = advFCMData.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

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

    return __result;
}

bool moddualcamSyncCCTDifftV1Type::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, "triggerPt") == 0)
    {
        __result = triggerPt.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool moddualcamSyncCCTDifftV1Type::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, "triggerPt") == 0)
    {
        __result = triggerPt.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

    return __result;
}

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

    return __result;
}

bool modmulticamSyncV1Type::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") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enable = (BOOL)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "colorMapping") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            colorMapping = (dualcamColorMappingType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "dynamicMixing") == 0)
    {
        __result = dynamicMixing.SetValue(&__path[__pos], __value);
    }

    return __result;
}

bool modmulticamSyncV1Type::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
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("enable", ParameterParserDataType::Boolean, (double)enable, 0));
    }
    else if (PARAMETER_STRCMP(__name, "enable") == 0)
    {
        __result = true;
        __info.Add(ParameterParserInfo(nullptr, ParameterParserDataType::Boolean, (double)enable, 0));
    }

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

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

    return __result;
}

bool moddualcamSyncV1Level2Type::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, "triggerPt") == 0)
    {
        __result = triggerPt.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool moddualcamSyncV1Level2Type::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, "triggerPt") == 0)
    {
        __result = triggerPt.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

bool moddualcamSyncV1Level1Type::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, "triggerPt") == 0)
    {
        __result = triggerPt.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool moddualcamSyncV1Level1Type::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, "triggerPt") == 0)
    {
        __result = triggerPt.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

bool moddualcamSyncWeightFCMType::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, "triggerPt") == 0)
    {
        __result = triggerPt.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool moddualcamSyncWeightFCMType::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, "triggerPt") == 0)
    {
        __result = triggerPt.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

bool moddualcamSyncOutlierV1Type::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, "triggerPt") == 0)
    {
        __result = triggerPt.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].GetValue(&__path[__pos], __value, __size);
        }
    }

    return __result;
}

bool moddualcamSyncOutlierV1Type::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, "triggerPt") == 0)
    {
        __result = triggerPt.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "triggerData") == 0)
    {
        if (__index < triggerDataCount)
        {
            __result = triggerData[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

    return __result;
}

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

    return __result;
}

bool moddualcamSyncRefPtV1Type::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, "condition") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            condition = (dualcamRefPtConditiontype)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "calFactor") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            calFactor = (INT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "point") == 0)
    {
        __result = point.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

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

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

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

    return __result;
}

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

    return __result;
}

bool moddualcamSyncCusRefPtV1Type::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, "luxThreshold") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            luxThreshold = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "luxRange") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            luxRange = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "refPt") == 0)
    {
        if (__index < refPtCount)
        {
            __result = refPt[__index].SetValue(&__path[__pos], __value);
        }
    }

    return __result;
}

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

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

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

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

    return __result;
}

bool chromatixdualcamSyncV1Type::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, "moduleID") == 0)
    {
        __result = moduleID.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, "enableFlag") == 0)
    {
        ParameterUtils::DoubleToString((double)enableFlag, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "modeSelection") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)modeSelection, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "convSpeed") == 0)
    {
        ParameterUtils::DoubleToString((double)convSpeed, __value, __size);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "refPtSelection") == 0)
    {
        ParameterUtils::DoubleToString((double)(UINT32)refPtSelection, __value, __size, 0);
        __result = true;
    }
    else if (PARAMETER_STRCMP(__name, "customRefPt") == 0)
    {
        __result = customRefPt.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "outlierDistance") == 0)
    {
        __result = outlierDistance.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "weightFCM") == 0)
    {
        __result = weightFCM.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "advMulitcamSync") == 0)
    {
        __result = advMulitcamSync.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "extMultiCamSync") == 0)
    {
        __result = extMultiCamSync.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "dynamicMode") == 0)
    {
        __result = dynamicMode.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "overlapColorMatchingSync") == 0)
    {
        __result = overlapColorMatchingSync.GetValue(&__path[__pos], __value, __size);
    }
    else if (PARAMETER_STRCMP(__name, "resultBlender") == 0)
    {
        __result = resultBlender.GetValue(&__path[__pos], __value, __size);
    }

    return __result;
}

bool chromatixdualcamSyncV1Type::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, "moduleID") == 0)
    {
        __result = moduleID.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "module_version") == 0)
    {
        __result = module_version.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "enableFlag") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            enableFlag = (awbglobalelements::enableFlagType)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "modeSelection") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            modeSelection = (dualcamSyncModeType)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "convSpeed") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            convSpeed = (float)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "refPtSelection") == 0)
    {
        const double dblValue = ParameterUtils::StringToDouble(__value, __result);
        if (__result)
        {
            refPtSelection = (dualcamRefPtSelecttype)(UINT32)dblValue; 
        }
    }
    else if (PARAMETER_STRCMP(__name, "customRefPt") == 0)
    {
        __result = customRefPt.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "outlierDistance") == 0)
    {
        __result = outlierDistance.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "weightFCM") == 0)
    {
        __result = weightFCM.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "advMulitcamSync") == 0)
    {
        __result = advMulitcamSync.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "extMultiCamSync") == 0)
    {
        __result = extMultiCamSync.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "dynamicMode") == 0)
    {
        __result = dynamicMode.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "overlapColorMatchingSync") == 0)
    {
        __result = overlapColorMatchingSync.SetValue(&__path[__pos], __value);
    }
    else if (PARAMETER_STRCMP(__name, "resultBlender") == 0)
    {
        __result = resultBlender.SetValue(&__path[__pos], __value);
    }

    return __result;
}

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

    // moduleID
    if (__name[0] == '\0')
    {
        __result = true;
        __info.Add(ParameterParserInfo("moduleID", ParameterParserDataType::Structure));
    }
    else if (PARAMETER_STRCMP(__name, "moduleID") == 0)
    {
        __result = moduleID.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);
    }

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

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

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

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

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

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

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

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

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

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

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

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

    return __result;
}

bool chromatixdualcamSyncV1Type::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;

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

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

    return __result;
}

bool chromatixdualcamSyncV1Type::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;

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

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

    return __result;
}

bool chromatixdualcamSyncV1Type::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;

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

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

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

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

    return __result;
}

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

    return __result;
}

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

    return __result;
}

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

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

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

    return __result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixdualcamSyncV1TypeClass::chromatixdualcamSyncV1TypeClass(
    const CHAR* name)
    : ParameterModule(name, MAJOR, MINOR, PATCH, nullptr)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(moduleID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(enableFlag);
    PARAMETER_INITIALIZE(modeSelection);
    PARAMETER_INITIALIZE(convSpeed);
    PARAMETER_INITIALIZE(refPtSelection);
    PARAMETER_INITIALIZE(customRefPt);
    PARAMETER_INITIALIZE(outlierDistance);
    PARAMETER_INITIALIZE(weightFCM);
    PARAMETER_INITIALIZE(advMulitcamSync);
    PARAMETER_INITIALIZE(extMultiCamSync);
    PARAMETER_INITIALIZE(dynamicMode);
    PARAMETER_INITIALIZE(overlapColorMatchingSync);
    PARAMETER_INITIALIZE(resultBlender);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixdualcamSyncV1TypeClass::chromatixdualcamSyncV1TypeClass(
    const CHAR*       name,
    ModuleData* const moduleData)
    : ParameterModule(name, MAJOR, MINOR, PATCH, moduleData)
{
    PARAMETER_INITIALIZE(SymbolTableID);
    PARAMETER_INITIALIZE(moduleID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(enableFlag);
    PARAMETER_INITIALIZE(modeSelection);
    PARAMETER_INITIALIZE(convSpeed);
    PARAMETER_INITIALIZE(refPtSelection);
    PARAMETER_INITIALIZE(customRefPt);
    PARAMETER_INITIALIZE(outlierDistance);
    PARAMETER_INITIALIZE(weightFCM);
    PARAMETER_INITIALIZE(advMulitcamSync);
    PARAMETER_INITIALIZE(extMultiCamSync);
    PARAMETER_INITIALIZE(dynamicMode);
    PARAMETER_INITIALIZE(overlapColorMatchingSync);
    PARAMETER_INITIALIZE(resultBlender);
}

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


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load resultBlenderType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void resultBlenderType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enableResultBlenderFlag);
    PARAMETER_INITIALIZE(BFWsConfidenceLevelCount);
    PARAMETER_INITIALIZE(BFWsConfidenceLevel);
    PARAMETER_INITIALIZE(BGWsConfidenceLevelCount);
    PARAMETER_INITIALIZE(BGWsConfidenceLevel);
    PARAMETER_INITIALIZE(ColorMappingConfidenceLevelCount);
    PARAMETER_INITIALIZE(ColorMappingConfidenceLevel);

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

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

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

        localParams.NameHash = 0xdc3cd27d03336f1e;
        entry->ReadSimpleTypeFixedArray(&enableResultBlenderFlag, 1, localParams);
        localParams.NameHash = 0xa7e8136c45fa5717;
        entry->ReadStructureArray(BFWsConfidenceLevel, BFWsConfidenceLevelCount, BFWsConfidenceLevelID, 1, localParams, __COUNTER__);
        localParams.NameHash = 0xe0858a96d25376a2;
        entry->ReadStructureArray(BGWsConfidenceLevel, BGWsConfidenceLevelCount, BGWsConfidenceLevelID, 1, localParams, __COUNTER__);
        localParams.NameHash = 0xfef99b1e1fc608ff;
        entry->ReadStructureArray(ColorMappingConfidenceLevel, ColorMappingConfidenceLevelCount, ColorMappingConfidenceLevelID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modBayerFloatingWindowsSynctype
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modBayerFloatingWindowsSynctype::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enableBFWSyncFlag);
    PARAMETER_INITIALIZE(BayerFloatingWindowsListCount);
    PARAMETER_INITIALIZE(BayerFloatingWindowsList);
    PARAMETER_INITIALIZE(BFWsOutlierTolerance);
    PARAMETER_INITIALIZE(BFWsOutlierDistanceWeightTrigger);

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

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

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

        localParams.NameHash = 0x96acffe43658b3a6;
        entry->ReadSimpleTypeFixedArray(&enableBFWSyncFlag, 1, localParams);
        localParams.NameHash = 0xbb577b68c0e389d1;
        entry->ReadStructureArray(BayerFloatingWindowsList, BayerFloatingWindowsListCount, BayerFloatingWindowsListID, 1, localParams, __COUNTER__);
        localParams.NameHash = 0xc4b03b4b317cfcda;
        entry->ReadSimpleTypeFixedArray(&BFWsOutlierTolerance, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xbdbbaadc02fcb415;
        BFWsOutlierDistanceWeightTrigger.Load(localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modBayerGridWindowsSynctype
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modBayerGridWindowsSynctype::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enableBGWsFlag);
    PARAMETER_INITIALIZE(enableROIAlignmentEveryFrameFlag);
    PARAMETER_INITIALIZE(enableDynamicAlignmentFlag);
    PARAMETER_INITIALIZE(BayerGridWindowsListCount);
    PARAMETER_INITIALIZE(BayerGridWindowsList);
    PARAMETER_INITIALIZE(templateMatchingROInumber);
    PARAMETER_INITIALIZE(BGWsOutlierTolerance);
    PARAMETER_INITIALIZE(BGWsOutlierDistanceWeightTrigger);
    PARAMETER_INITIALIZE(scoreThres);
    PARAMETER_INITIALIZE(scoreImproveThres);
    PARAMETER_INITIALIZE(offsetThres);

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

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

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

        localParams.NameHash = 0xb2e4215bebc76824;
        entry->ReadSimpleTypeFixedArray(&enableBGWsFlag, 1, localParams);
        localParams.NameHash = 0xebcb20d882649788;
        entry->ReadSimpleTypeFixedArray(&enableROIAlignmentEveryFrameFlag, 1, localParams);
        localParams.NameHash = 0xf4850b0d26eae873;
        entry->ReadSimpleTypeFixedArray(&enableDynamicAlignmentFlag, 1, localParams);
        localParams.NameHash = 0xf6efaabe01783cfb;
        entry->ReadStructureArray(BayerGridWindowsList, BayerGridWindowsListCount, BayerGridWindowsListID, 1, localParams, __COUNTER__);
        localParams.NameHash = 0x9d8ecb529ca44d10;
        entry->ReadSimpleTypeFixedArray(&templateMatchingROInumber, 1, localParams);
        localParams.NameHash = 0xa4e66287924f5522;
        entry->ReadSimpleTypeFixedArray(&BGWsOutlierTolerance, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xda5d42c89fb56e43;
        BGWsOutlierDistanceWeightTrigger.Load(localParams);
        localParams.NameHash = 0xd130006685686aff;
        entry->ReadSimpleTypeFixedArray(&scoreThres, 1, localParams);
        localParams.NameHash = 0xe52cc68ee136bb27;
        entry->ReadSimpleTypeFixedArray(&scoreImproveThres, 1, localParams);
        localParams.NameHash = 0xf1452ad50cb196a1;
        entry->ReadSimpleTypeFixedArray(&offsetThres, 1, localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncDynamicModeType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncDynamicModeType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(threshold);
    PARAMETER_INITIALIZE(res1);
    PARAMETER_INITIALIZE(res2);

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

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

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

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xe04ba95df59bbd7c;
        entry->ReadSimpleTypeFixedArray(&threshold, 1, localParams);
        localParams.NameHash = 0xa02c458dca62f62b;
        entry->ReadSimpleTypeFixedArray(&res1, 1, localParams);
        localParams.NameHash = 0xe900faecd72e0a25;
        entry->ReadSimpleTypeFixedArray(&res2, 1, localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modmulticamSyncTriglInfoType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamSyncTriglInfoType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(VertexIdx);
    PARAMETER_INITIALIZE(sideIdx);

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

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

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

        localParams.NameHash = 0xc5ad5354b471a8d6;
        entry->ReadSimpleTypeFixedArray<INT32>(VertexIdx, VertexIdxFixedCount,
            localParams);
        localParams.NameHash = 0xb89178690d30ecc3;
        entry->ReadSimpleTypeFixedArray<INT32>(sideIdx, sideIdxFixedCount,
            localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modmultiCamSyncadvFCMTriglData
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmultiCamSyncadvFCMTriglData::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(TriglDataCount);
    PARAMETER_INITIALIZE(TriglData);
    PARAMETER_INITIALIZE(vertexDataCount);
    PARAMETER_INITIALIZE(vertexData);

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

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

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

        localParams.NameHash = 0x9eb386c6e55441fd;
        entry->ReadStructureArray(TriglData, TriglDataCount, TriglDataID, 1, localParams, __COUNTER__);
        localParams.NameHash = 0x8cba3af4d565e95a;
        entry->ReadStructureArray(vertexData, vertexDataCount, vertexDataID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modmulticamSyncadvFCMCCTtriggerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamSyncadvFCMCCTtriggerType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xcb944a716851ffce;
        triggerPt.Load(localParams);
        localParams.NameHash        = 0xd5dc9fcb428af073;
        triggerData.Load(localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modmulticamSyncadvFCMType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamSyncadvFCMType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerDataCount);
    PARAMETER_INITIALIZE(triggerData);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xcb944a716851ffce;
        triggerPt.Load(localParams);
        localParams.NameHash = 0xd5dc9fcb428af073;
        entry->ReadStructureArray(triggerData, triggerDataCount, triggerDataID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modmulticamExtSynctype
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamExtSynctype::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enableFlag);
    PARAMETER_INITIALIZE(enableAlwaysFollowFlag);
    PARAMETER_INITIALIZE(enableInstantFCMStartFlag);
    PARAMETER_INITIALIZE(advFCMData);

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

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

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

        localParams.NameHash = 0x89a1d7b1468113d1;
        entry->ReadSimpleTypeFixedArray(&enableFlag, 1, localParams);
        localParams.NameHash = 0xb07dc2a68c85f4a9;
        entry->ReadSimpleTypeFixedArray(&enableAlwaysFollowFlag, 1, localParams);
        localParams.NameHash = 0xf90cd43e2b0fc6c0;
        entry->ReadSimpleTypeFixedArray(&enableInstantFCMStartFlag, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xab7ba68269930bcb;
        advFCMData.Load(localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncCCTDifftV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncCCTDifftV1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerDataCount);
    PARAMETER_INITIALIZE(triggerData);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xcb944a716851ffce;
        triggerPt.Load(localParams);
        localParams.NameHash = 0xd5dc9fcb428af073;
        entry->ReadStructureArray(triggerData, triggerDataCount, triggerDataID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncMixingV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncMixingV1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(cctDiffWeight);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xb93c921f5640afe8;
        cctDiffWeight.Load(localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modmulticamSyncV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamSyncV1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(colorMapping);
    PARAMETER_INITIALIZE(dynamicMixing);

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

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

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

        localParams.NameHash = 0xb3c00adf8e304e57;
        entry->ReadSimpleTypeFixedArray(&enable, 1, localParams);
        localParams.NameHash = 0xee7bfb4e7b85387d;
        entry->ReadEnumFixedArray(&colorMapping, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xdd8910a5f82ea478;
        dynamicMixing.Load(localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load modmulticamAdvSyncV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamAdvSyncV1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(master);
    PARAMETER_INITIALIZE(slave);
    PARAMETER_INITIALIZE(slaveOptMode);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xd6502a4055fa55b2;
        master.Load(localParams);
        localParams.NameHash        = 0xddd6fc12196a1251;
        slave.Load(localParams);
        localParams.NameHash = 0xda64d52e7cca42c5;
        entry->ReadEnumFixedArray(&slaveOptMode, 1, localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncV1Level2Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncV1Level2Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerDataCount);
    PARAMETER_INITIALIZE(triggerData);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xcb944a716851ffce;
        triggerPt.Load(localParams);
        localParams.NameHash = 0xd5dc9fcb428af073;
        entry->ReadStructureArray(triggerData, triggerDataCount, triggerDataID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncV1Level1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncV1Level1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerDataCount);
    PARAMETER_INITIALIZE(triggerData);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xcb944a716851ffce;
        triggerPt.Load(localParams);
        localParams.NameHash = 0xd5dc9fcb428af073;
        entry->ReadStructureArray(triggerData, triggerDataCount, triggerDataID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncWeightFCMType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncWeightFCMType::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerDataCount);
    PARAMETER_INITIALIZE(triggerData);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xcb944a716851ffce;
        triggerPt.Load(localParams);
        localParams.NameHash = 0xd5dc9fcb428af073;
        entry->ReadStructureArray(triggerData, triggerDataCount, triggerDataID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncOutlierV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncOutlierV1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerDataCount);
    PARAMETER_INITIALIZE(triggerData);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xcb944a716851ffce;
        triggerPt.Load(localParams);
        localParams.NameHash = 0xd5dc9fcb428af073;
        entry->ReadStructureArray(triggerData, triggerDataCount, triggerDataID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncRefPtV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncRefPtV1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(condition);
    PARAMETER_INITIALIZE(calFactor);
    PARAMETER_INITIALIZE(point);

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

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

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

        localParams.NameHash = 0xd05ed5e87e4b1cf7;
        entry->ReadEnumFixedArray(&condition, 1, localParams);
        localParams.NameHash = 0x8c69789b575241b3;
        entry->ReadSimpleTypeFixedArray(&calFactor, 1, localParams);
        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xe4d0019d1c87df5d;
        point.Load(localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load moddualcamSyncCusRefPtV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncCusRefPtV1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(luxThreshold);
    PARAMETER_INITIALIZE(luxRange);
    PARAMETER_INITIALIZE(refPtCount);
    PARAMETER_INITIALIZE(refPt);

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

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

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

        localParams.NameHash = 0xdc789c75b74e907e;
        entry->ReadSimpleTypeFixedArray(&luxThreshold, 1, localParams);
        localParams.NameHash = 0xf798b67ccaa485ee;
        entry->ReadSimpleTypeFixedArray(&luxRange, 1, localParams);
        localParams.NameHash = 0xa7994c269c865197;
        entry->ReadStructureArray(refPt, refPtCount, refPtID, 1, localParams, __COUNTER__);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load chromatixdualcamSyncV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixdualcamSyncV1Type::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(moduleID);
    PARAMETER_INITIALIZE(module_version);
    PARAMETER_INITIALIZE(enableFlag);
    PARAMETER_INITIALIZE(modeSelection);
    PARAMETER_INITIALIZE(convSpeed);
    PARAMETER_INITIALIZE(refPtSelection);
    PARAMETER_INITIALIZE(customRefPt);
    PARAMETER_INITIALIZE(outlierDistance);
    PARAMETER_INITIALIZE(weightFCM);
    PARAMETER_INITIALIZE(advMulitcamSync);
    PARAMETER_INITIALIZE(extMultiCamSync);
    PARAMETER_INITIALIZE(dynamicMode);
    PARAMETER_INITIALIZE(overlapColorMatchingSync);
    PARAMETER_INITIALIZE(resultBlender);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0xb5bb6c7a408ed007;
        moduleID.Load(localParams);
        localParams.NameHash        = 0xe11cd9f365a2599f;
        module_version.Load(localParams);
        localParams.NameHash = 0x89a1d7b1468113d1;
        entry->ReadSimpleTypeFixedArray(&enableFlag, 1, localParams);
        localParams.NameHash = 0xb46649907ef00a2a;
        entry->ReadEnumFixedArray(&modeSelection, 1, localParams);
        localParams.NameHash = 0xe63f8b4aa009355a;
        entry->ReadSimpleTypeFixedArray(&convSpeed, 1, localParams);
        localParams.NameHash = 0xa9c9471ed8847b6c;
        entry->ReadEnumFixedArray(&refPtSelection, 1, localParams);
        localParams.NameHash        = 0x8c35187339583684;
        customRefPt.Load(localParams);
        localParams.NameHash        = 0xb307d646999f5e15;
        outlierDistance.Load(localParams);
        localParams.NameHash        = 0xe129ec93bbc31b03;
        weightFCM.Load(localParams);
        localParams.NameHash        = 0x85860dc636f89e51;
        advMulitcamSync.Load(localParams);
        localParams.NameHash        = 0x85d123e5b97dcb58;
        extMultiCamSync.Load(localParams);
        localParams.NameHash        = 0xa1dbbae54eeaee0d;
        dynamicMode.Load(localParams);
        localParams.NameHash        = 0xe4a3457ec1a5f5fa;
        overlapColorMatchingSync.Load(localParams);
        localParams.NameHash        = 0x92b9c9eccfed17e4;
        resultBlender.Load(localParams);

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

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

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

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

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

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

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

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

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Load overlapColorMatchingSyncStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixdualcamSyncV1Type::overlapColorMatchingSyncStruct::Load(
    ParameterLoadParameters& parentParams)
{
    PARAMETER_INITIALIZE(BayerGridWindowsSync);
    PARAMETER_INITIALIZE(BayerFloatingWindowsSync);

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

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

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

        localParams.UseParent       = false;
        localParams.UseParentOffset = true;
        localParams.NameHash        = 0x81ac4804772a1ed0;
        BayerGridWindowsSync.Load(localParams);
        localParams.NameHash        = 0xcc1499d2b6b1abfa;
        BayerFloatingWindowsSync.Load(localParams);

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload resultBlenderType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void resultBlenderType::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; BFWsConfidenceLevel != nullptr && i < BFWsConfidenceLevelCount; i++)
    {
        BFWsConfidenceLevel[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, BFWsConfidenceLevel);
    for (UINT32 i = 0; BGWsConfidenceLevel != nullptr && i < BGWsConfidenceLevelCount; i++)
    {
        BGWsConfidenceLevel[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, BGWsConfidenceLevel);
    for (UINT32 i = 0; ColorMappingConfidenceLevel != nullptr && i < ColorMappingConfidenceLevelCount; i++)
    {
        ColorMappingConfidenceLevel[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, ColorMappingConfidenceLevel);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload modBayerFloatingWindowsSynctype
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modBayerFloatingWindowsSynctype::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, BayerFloatingWindowsList);
    BFWsOutlierDistanceWeightTrigger.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload modBayerGridWindowsSynctype
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modBayerGridWindowsSynctype::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, BayerGridWindowsList);
    BGWsOutlierDistanceWeightTrigger.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload modmultiCamSyncadvFCMTriglData
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmultiCamSyncadvFCMTriglData::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, TriglData);
    ParameterFileSymbolTable::ReleaseObject(__table, vertexData);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload modmulticamSyncadvFCMCCTtriggerType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamSyncadvFCMCCTtriggerType::Unload(ParameterFileSymbolTable* const __table)
{
    triggerData.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload modmulticamSyncadvFCMType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamSyncadvFCMType::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; triggerData != nullptr && i < triggerDataCount; i++)
    {
        triggerData[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, triggerData);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload modmulticamExtSynctype
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamExtSynctype::Unload(ParameterFileSymbolTable* const __table)
{
    advFCMData.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload moddualcamSyncCCTDifftV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncCCTDifftV1Type::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, triggerData);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload moddualcamSyncMixingV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncMixingV1Type::Unload(ParameterFileSymbolTable* const __table)
{
    cctDiffWeight.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload modmulticamSyncV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamSyncV1Type::Unload(ParameterFileSymbolTable* const __table)
{
    dynamicMixing.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload modmulticamAdvSyncV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void modmulticamAdvSyncV1Type::Unload(ParameterFileSymbolTable* const __table)
{
    master.Unload(__table);
    slave.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload moddualcamSyncV1Level2Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncV1Level2Type::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, triggerData);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload moddualcamSyncV1Level1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncV1Level1Type::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; triggerData != nullptr && i < triggerDataCount; i++)
    {
        triggerData[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, triggerData);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload moddualcamSyncWeightFCMType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncWeightFCMType::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; triggerData != nullptr && i < triggerDataCount; i++)
    {
        triggerData[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, triggerData);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload moddualcamSyncOutlierV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncOutlierV1Type::Unload(ParameterFileSymbolTable* const __table)
{
    for (UINT32 i = 0; triggerData != nullptr && i < triggerDataCount; i++)
    {
        triggerData[i].Unload(__table);
    }
    ParameterFileSymbolTable::ReleaseObject(__table, triggerData);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload moddualcamSyncCusRefPtV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void moddualcamSyncCusRefPtV1Type::Unload(ParameterFileSymbolTable* const __table)
{
    ParameterFileSymbolTable::ReleaseObject(__table, refPt);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload chromatixdualcamSyncV1Type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixdualcamSyncV1Type::Unload(ParameterFileSymbolTable* const __table)
{
    customRefPt.Unload(__table);
    outlierDistance.Unload(__table);
    weightFCM.Unload(__table);
    advMulitcamSync.Unload(__table);
    extMultiCamSync.Unload(__table);
    overlapColorMatchingSync.Unload(__table);
    resultBlender.Unload(__table);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload overlapColorMatchingSyncStruct
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixdualcamSyncV1Type::overlapColorMatchingSyncStruct::Unload(ParameterFileSymbolTable* const __table)
{
    BayerGridWindowsSync.Unload(__table);
    BayerFloatingWindowsSync.Unload(__table);
}

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GetModuleName: Returns ParameterModule::Name variable
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const CHAR* chromatixdualcamSyncV1Type::GetModuleName()
{
    return ((chromatixdualcamSyncV1TypeClass*)this)->Name;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// GetModuleName: Returns ParameterModule::NameHash variable
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
UINT64 chromatixdualcamSyncV1Type::GetModuleNameHash()
{
    return ((chromatixdualcamSyncV1TypeClass*)this)->NameHash;
}

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

    if (IsModuleMatch(moduleData) && 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 = (chromatixdualcamSyncV1TypeClass*)module;
        }
        else
        {
            cls = PARAMETER_NEW chromatixdualcamSyncV1TypeClass(Name, moduleData);
            cls->SymbolTableID = id;
            defModule->AddModule((ParameterModule*)cls);
        }
    }
    else if (Version.Value != moduleData->Version.Value)
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatixdualcamSyncV1TypeClass, binary version (%lld) does not match source version (%lld)\n",
            moduleData->Version.Value, Version.Value);
    }
    else
    {
        PARAMETER_LOG_ERROR(moduleData->SetManager, "Unable to create chromatixdualcamSyncV1TypeClass, binary name hash (0x%016llx) does not match source name hash (0x%016llx)\n",
            moduleData->NameHash, NameHash);
    }

    return (ParameterModule*)cls;
}

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

#ifdef PARAMETER_USE_MUTEX
    ParameterMutexLocker lock(Mutex); // Unique LOCK
#endif

    if (!Loaded)
    {
        chromatixdualcamSyncV1TypeClass* 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 & 0x00ffffffU);

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


        ParameterDefinitionElement* _element = nullptr;
        if (table->ModuleDefinitions != nullptr && !table->ModuleDefinitions->empty())
        {
            _element = table->BuildModuleElement(NameHash);
        }

        ParameterLoadParameters parentParams(entry, NameHash, true, true, _element, entry->Position, 0, ParameterFileSymbolTableEntry::LOAD_LIMIT_MAX);
        cls->Load(parentParams);
        PARAMETER_DELETE _element;
        Modified++;
        Loaded = true;
    }

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

    return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Unload module data
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void chromatixdualcamSyncV1TypeClass::UnloadModule()
{
#ifdef PARAMETER_USE_MUTEX
    ParameterMutexLocker lock(Mutex); // Unique LOCK
#endif

    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 chromatixdualcamSyncV1TypeClass::Release()
{
    ParameterModule::Release();
}

MODDUALCAMSYNCV1_NAMESPACE_END
