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

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

    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;

    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;

    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;

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

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

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

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

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

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

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

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

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

                const double dblValue = ParameterUtils::StringToDouble(__valueStr, __result);
                if (__result)
                {
                    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;

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

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

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

    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;

    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;

    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;

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

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(dualcamSyncModeType::SYNCON):
            enumValue = dualcamSyncModeType::SYNCON;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamSyncModeType::SYNCOFF):
            enumValue = dualcamSyncModeType::SYNCOFF;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to dualcamSyncModeType", uintValue);
            break;
        }
    }
    return result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(dualcamRefPtConditiontype::AllConditions):
            enumValue = dualcamRefPtConditiontype::AllConditions;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamRefPtConditiontype::Outdoor):
            enumValue = dualcamRefPtConditiontype::Outdoor;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamRefPtConditiontype::Indoor):
            enumValue = dualcamRefPtConditiontype::Indoor;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to dualcamRefPtConditiontype", uintValue);
            break;
        }
    }
    return result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(dualcamRefPtSelecttype::UseBoth):
            enumValue = dualcamRefPtSelecttype::UseBoth;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamRefPtSelecttype::UseRefPtOnly):
            enumValue = dualcamRefPtSelecttype::UseRefPtOnly;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamRefPtSelecttype::UseCustRefPtOnly):
            enumValue = dualcamRefPtSelecttype::UseCustRefPtOnly;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to dualcamRefPtSelecttype", uintValue);
            break;
        }
    }
    return result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(dualcamColorMappingType::FCM):
            enumValue = dualcamColorMappingType::FCM;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamColorMappingType::FCMAndGCM):
            enumValue = dualcamColorMappingType::FCMAndGCM;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to dualcamColorMappingType", uintValue);
            break;
        }
    }
    return result;
}

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

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

    if (result)
    {
        switch (uintValue)
        {
        case static_cast<UINT32>(dualcamSlaveOptimzationType::SlaveOptOff):
            enumValue = dualcamSlaveOptimzationType::SlaveOptOff;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamSlaveOptimzationType::SlaveOptFiltersAndAnalyzers):
            enumValue = dualcamSlaveOptimzationType::SlaveOptFiltersAndAnalyzers;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamSlaveOptimzationType::SlaveOptReducedStats):
            enumValue = dualcamSlaveOptimzationType::SlaveOptReducedStats;
            result    = true;
            break;
        case static_cast<UINT32>(dualcamSlaveOptimzationType::SlaveOptMaxType):
            enumValue = dualcamSlaveOptimzationType::SlaveOptMaxType;
            result    = true;
            break;
        default:
            PARAMETER_LOG_ERROR(entry->SetManager, "Invalid value(% u) converting UINT32 to dualcamSlaveOptimzationType", uintValue);
            break;
        }
    }
    return result;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default Constructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
chromatixdualcamSyncV1TypeClass::chromatixdualcamSyncV1TypeClass(
    const CHAR* const 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* const 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();
    }
}

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

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

    PARAMETER_INITIALIZE(enableResultBlenderFlag);
    PARAMETER_INITIALIZE(BFWsConfidenceLevel);
    PARAMETER_INITIALIZE(BGWsConfidenceLevel);
    PARAMETER_INITIALIZE(ColorMappingConfidenceLevel);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableResultBlenderFlag, alignment)

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

        if (result)
        {
            BFWsConfidenceLevelID = pointerEntry->ID;
            DupObjInfo* BFWsConfidenceLevelDupInfo = pointerEntry->GetDupObject(BFWsConfidenceLevelCount, file, line);
            if (BFWsConfidenceLevelDupInfo != nullptr && BFWsConfidenceLevelDupInfo->Object != nullptr)
            {
                BFWsConfidenceLevel = (awbglobalelements::awbSAConfidenceDataType*)BFWsConfidenceLevelDupInfo->Object;
                if (BFWsConfidenceLevel == nullptr)
                {
                    if (BFWsConfidenceLevelDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "BFWsConfidenceLevel duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            BFWsConfidenceLevelDupInfo->File, BFWsConfidenceLevelDupInfo->Line, BFWsConfidenceLevelDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "BFWsConfidenceLevel duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            BFWsConfidenceLevelDupInfo->Line, BFWsConfidenceLevelDupInfo->RefCount);
                    }
                }
            }

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

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

        if (result)
        {
            BGWsConfidenceLevelID = pointerEntry->ID;
            DupObjInfo* BGWsConfidenceLevelDupInfo = pointerEntry->GetDupObject(BGWsConfidenceLevelCount, file, line);
            if (BGWsConfidenceLevelDupInfo != nullptr && BGWsConfidenceLevelDupInfo->Object != nullptr)
            {
                BGWsConfidenceLevel = (awbglobalelements::awbSAConfidenceDataType*)BGWsConfidenceLevelDupInfo->Object;
                if (BGWsConfidenceLevel == nullptr)
                {
                    if (BGWsConfidenceLevelDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "BGWsConfidenceLevel duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            BGWsConfidenceLevelDupInfo->File, BGWsConfidenceLevelDupInfo->Line, BGWsConfidenceLevelDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "BGWsConfidenceLevel duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            BGWsConfidenceLevelDupInfo->Line, BGWsConfidenceLevelDupInfo->RefCount);
                    }
                }
            }

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

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

        if (result)
        {
            ColorMappingConfidenceLevelID = pointerEntry->ID;
            DupObjInfo* ColorMappingConfidenceLevelDupInfo = pointerEntry->GetDupObject(ColorMappingConfidenceLevelCount, file, line);
            if (ColorMappingConfidenceLevelDupInfo != nullptr && ColorMappingConfidenceLevelDupInfo->Object != nullptr)
            {
                ColorMappingConfidenceLevel = (awbglobalelements::awbSAConfidenceDataType*)ColorMappingConfidenceLevelDupInfo->Object;
                if (ColorMappingConfidenceLevel == nullptr)
                {
                    if (ColorMappingConfidenceLevelDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "ColorMappingConfidenceLevel duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            ColorMappingConfidenceLevelDupInfo->File, ColorMappingConfidenceLevelDupInfo->Line, ColorMappingConfidenceLevelDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "ColorMappingConfidenceLevel duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            ColorMappingConfidenceLevelDupInfo->Line, ColorMappingConfidenceLevelDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(enableBFWSyncFlag);
    PARAMETER_INITIALIZE(BayerFloatingWindowsList);
    PARAMETER_INITIALIZE(BFWsOutlierTolerance);
    PARAMETER_INITIALIZE(BFWsOutlierDistanceWeightTrigger);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableBFWSyncFlag, alignment)

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

        if (result)
        {
            BayerFloatingWindowsListID = pointerEntry->ID;
            DupObjInfo* BayerFloatingWindowsListDupInfo = pointerEntry->GetDupObject(BayerFloatingWindowsListCount, file, line);
            if (BayerFloatingWindowsListDupInfo != nullptr && BayerFloatingWindowsListDupInfo->Object != nullptr)
            {
                BayerFloatingWindowsList = (awbglobalelements::awbWindowType*)BayerFloatingWindowsListDupInfo->Object;
                if (BayerFloatingWindowsList == nullptr)
                {
                    if (BayerFloatingWindowsListDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "BayerFloatingWindowsList duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            BayerFloatingWindowsListDupInfo->File, BayerFloatingWindowsListDupInfo->Line, BayerFloatingWindowsListDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "BayerFloatingWindowsList duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            BayerFloatingWindowsListDupInfo->Line, BayerFloatingWindowsListDupInfo->RefCount);
                    }
                }
            }

            if (BayerFloatingWindowsList == nullptr)
            {
                if (result && BayerFloatingWindowsListCount > 0)
                {
                    BayerFloatingWindowsList = PARAMETER_NEW awbglobalelements::awbWindowType[BayerFloatingWindowsListCount];
                    (void)pointerEntry->SetDupObject(BayerFloatingWindowsList, BayerFloatingWindowsListCount, file, line);
                }
                if (!result || BayerFloatingWindowsList == nullptr)
                {
                    if (BayerFloatingWindowsListCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate BayerFloatingWindowsList\n");
                    }
                    BayerFloatingWindowsListCount = 0;
                }
                for (UINT32 i = 0; result && i < BayerFloatingWindowsListCount; i++)
                {
                    result = BayerFloatingWindowsList[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (BayerFloatingWindowsList == nullptr)
        {
            BayerFloatingWindowsListCount = 0;
        }
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, BFWsOutlierTolerance, alignment)
    if (result)
    {
        result = BFWsOutlierDistanceWeightTrigger.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(enableBGWsFlag);
    PARAMETER_INITIALIZE(enableROIAlignmentEveryFrameFlag);
    PARAMETER_INITIALIZE(enableDynamicAlignmentFlag);
    PARAMETER_INITIALIZE(BayerGridWindowsList);
    PARAMETER_INITIALIZE(templateMatchingROInumber);
    PARAMETER_INITIALIZE(BGWsOutlierTolerance);
    PARAMETER_INITIALIZE(BGWsOutlierDistanceWeightTrigger);
    PARAMETER_INITIALIZE(scoreThres);
    PARAMETER_INITIALIZE(scoreImproveThres);
    PARAMETER_INITIALIZE(offsetThres);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableBGWsFlag, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableROIAlignmentEveryFrameFlag, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableDynamicAlignmentFlag, alignment)

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

        if (result)
        {
            BayerGridWindowsListID = pointerEntry->ID;
            DupObjInfo* BayerGridWindowsListDupInfo = pointerEntry->GetDupObject(BayerGridWindowsListCount, file, line);
            if (BayerGridWindowsListDupInfo != nullptr && BayerGridWindowsListDupInfo->Object != nullptr)
            {
                BayerGridWindowsList = (awbglobalelements::awbWindowType*)BayerGridWindowsListDupInfo->Object;
                if (BayerGridWindowsList == nullptr)
                {
                    if (BayerGridWindowsListDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "BayerGridWindowsList duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            BayerGridWindowsListDupInfo->File, BayerGridWindowsListDupInfo->Line, BayerGridWindowsListDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "BayerGridWindowsList duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            BayerGridWindowsListDupInfo->Line, BayerGridWindowsListDupInfo->RefCount);
                    }
                }
            }

            if (BayerGridWindowsList == nullptr)
            {
                if (result && BayerGridWindowsListCount > 0)
                {
                    BayerGridWindowsList = PARAMETER_NEW awbglobalelements::awbWindowType[BayerGridWindowsListCount];
                    (void)pointerEntry->SetDupObject(BayerGridWindowsList, BayerGridWindowsListCount, file, line);
                }
                if (!result || BayerGridWindowsList == nullptr)
                {
                    if (BayerGridWindowsListCount > 0)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "Failed to allocate BayerGridWindowsList\n");
                    }
                    BayerGridWindowsListCount = 0;
                }
                for (UINT32 i = 0; result && i < BayerGridWindowsListCount; i++)
                {
                    result = BayerGridWindowsList[i].Load(pointerEntry, alignment);
                }
            }
        }
        if (BayerGridWindowsList == nullptr)
        {
            BayerGridWindowsListCount = 0;
        }
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, templateMatchingROInumber, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, BGWsOutlierTolerance, alignment)
    if (result)
    {
        result = BGWsOutlierDistanceWeightTrigger.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, scoreThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, scoreImproveThres, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, offsetThres, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(threshold);
    PARAMETER_INITIALIZE(res1);
    PARAMETER_INITIALIZE(res2);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, threshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, res1, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, res2, alignment)

    return result;
}

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

    PARAMETER_INITIALIZE(VertexIdx);
    PARAMETER_INITIALIZE(sideIdx);

    result = entry->ReadArray(VertexIdx, 3, alignment);
    if (result)
    {
        result = entry->ReadArray(sideIdx, 3, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(TriglData);
    PARAMETER_INITIALIZE(vertexData);


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

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

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

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

        if (result)
        {
            vertexDataID = pointerEntry->ID;
            DupObjInfo* vertexDataDupInfo = pointerEntry->GetDupObject(vertexDataCount, file, line);
            if (vertexDataDupInfo != nullptr && vertexDataDupInfo->Object != nullptr)
            {
                vertexData = (awbglobalelements::awbPointDataType*)vertexDataDupInfo->Object;
                if (vertexData == nullptr)
                {
                    if (vertexDataDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "vertexData duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            vertexDataDupInfo->File, vertexDataDupInfo->Line, vertexDataDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "vertexData duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            vertexDataDupInfo->Line, vertexDataDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);
    if (result)
    {
        result = triggerData.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(enableFlag);
    PARAMETER_INITIALIZE(enableAlwaysFollowFlag);
    PARAMETER_INITIALIZE(enableInstantFCMStartFlag);
    PARAMETER_INITIALIZE(advFCMData);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFlag, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableAlwaysFollowFlag, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableInstantFCMStartFlag, alignment)
    if (result)
    {
        result = advFCMData.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);

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

        if (result)
        {
            triggerDataID = pointerEntry->ID;
            DupObjInfo* triggerDataDupInfo = pointerEntry->GetDupObject(triggerDataCount, file, line);
            if (triggerDataDupInfo != nullptr && triggerDataDupInfo->Object != nullptr)
            {
                triggerData = (awbglobalelements::awbTriggerDataFloatType*)triggerDataDupInfo->Object;
                if (triggerData == nullptr)
                {
                    if (triggerDataDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "triggerData duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            triggerDataDupInfo->File, triggerDataDupInfo->Line, triggerDataDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "triggerData duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            triggerDataDupInfo->Line, triggerDataDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(cctDiffWeight);

    result = cctDiffWeight.Load(entry, alignment);

    return result;
}

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

    PARAMETER_INITIALIZE(enable);
    PARAMETER_INITIALIZE(colorMapping);
    PARAMETER_INITIALIZE(dynamicMixing);

    SYMBOL_TABLE_ENTRY_READ(entry, result, enable, alignment)
    if (result)
    {
        result = moddualcamsyncv1::ReadEnum_dualcamColorMappingType(entry, colorMapping, alignment);
    }
    if (result)
    {
        result = dynamicMixing.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(master);
    PARAMETER_INITIALIZE(slave);
    PARAMETER_INITIALIZE(slaveOptMode);

    result = master.Load(entry, alignment);
    if (result)
    {
        result = slave.Load(entry, alignment);
    }
    if (result)
    {
        result = moddualcamsyncv1::ReadEnum_dualcamSlaveOptimzationType(entry, slaveOptMode, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);

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

        if (result)
        {
            triggerDataID = pointerEntry->ID;
            DupObjInfo* triggerDataDupInfo = pointerEntry->GetDupObject(triggerDataCount, file, line);
            if (triggerDataDupInfo != nullptr && triggerDataDupInfo->Object != nullptr)
            {
                triggerData = (awbglobalelements::awbTriggerDataFloatType*)triggerDataDupInfo->Object;
                if (triggerData == nullptr)
                {
                    if (triggerDataDupInfo->File != nullptr)
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "triggerData duplicate found but object is nullptr: %s:%d, RefCount: %d\n",
                            triggerDataDupInfo->File, triggerDataDupInfo->Line, triggerDataDupInfo->RefCount);
                    }
                    else
                    {
                        PARAMETER_LOG_ERROR(entry->SetManager, "triggerData duplicate found but Object is nullptr: <nullptr file ptr>:%d, RefCount: %d\n",
                            triggerDataDupInfo->Line, triggerDataDupInfo->RefCount);
                    }
                }
            }

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

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(triggerPt);
    PARAMETER_INITIALIZE(triggerData);

    result = triggerPt.Load(entry, alignment);

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(condition);
    PARAMETER_INITIALIZE(calFactor);
    PARAMETER_INITIALIZE(point);

    result = moddualcamsyncv1::ReadEnum_dualcamRefPtConditiontype(entry, condition, alignment);
    SYMBOL_TABLE_ENTRY_READ(entry, result, calFactor, alignment)
    if (result)
    {
        result = point.Load(entry, alignment);
    }

    return result;
}

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

    PARAMETER_INITIALIZE(luxThreshold);
    PARAMETER_INITIALIZE(luxRange);
    PARAMETER_INITIALIZE(refPt);

    SYMBOL_TABLE_ENTRY_READ(entry, result, luxThreshold, alignment)
    SYMBOL_TABLE_ENTRY_READ(entry, result, luxRange, alignment)

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

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

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

    return result;
}

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

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

    result = moduleID.Load(entry, alignment);
    if (result)
    {
        result = module_version.Load(entry, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, enableFlag, alignment)
    if (result)
    {
        result = moddualcamsyncv1::ReadEnum_dualcamSyncModeType(entry, modeSelection, alignment);
    }
    SYMBOL_TABLE_ENTRY_READ(entry, result, convSpeed, alignment)
    if (result)
    {
        result = moddualcamsyncv1::ReadEnum_dualcamRefPtSelecttype(entry, refPtSelection, alignment);
    }
    if (result)
    {
        result = customRefPt.Load(entry, alignment);
    }
    if (result)
    {
        result = outlierDistance.Load(entry, alignment);
    }
    if (result)
    {
        result = weightFCM.Load(entry, alignment);
    }
    if (result)
    {
        result = advMulitcamSync.Load(entry, alignment);
    }
    if (result)
    {
        result = extMultiCamSync.Load(entry, alignment);
    }
    if (result)
    {
        result = dynamicMode.Load(entry, alignment);
    }
    if (result)
    {
        result = overlapColorMatchingSync.Load(entry, alignment);
    }
    if (result)
    {
        result = resultBlender.Load(entry, alignment);
    }

    return result;
}

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

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

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

    return result;
}

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

    PARAMETER_INITIALIZE(BayerGridWindowsSync);
    PARAMETER_INITIALIZE(BayerFloatingWindowsSync);

    result = BayerGridWindowsSync.Load(entry, alignment);
    if (result)
    {
        result = BayerFloatingWindowsSync.Load(entry, alignment);
    }

    return result;
}

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

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

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

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

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

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

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// 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)
{
    if (__table != nullptr && __table->ReleaseDupObject(triggerData))
    {
        PARAMETER_DELETE[] triggerData;
    }
    triggerData = nullptr;
}

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

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

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

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

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

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

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

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

    return (ParameterModule*)cls;
}

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

    if (!Loaded)
    {
        BYTE const alignment = table->Alignment;
        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 & 0x00ffffff);

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

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

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

    return result;
}

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

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

MODDUALCAMSYNCV1_NAMESPACE_END
