ERRORCODE CCommonLDFGenerator::nGenerateNodeCompositions()
{
    IEcu* pEcu = nullptr;
    std::string omEcuName;
    std::ostringstream omNodeComposition, omNodeConfiguration;
    std::map<UID_ELEMENT, IElement*> nodeCompMap;

    m_ouCluster->GetElementList(eLinNodeComposition, nodeCompMap);
    std::list<CompositeNode> lstCompNodes;
for(auto itrNodeComposition : nodeCompMap )
    {
        CLDFNodeConfiguration* ouNodeConfig = (CLDFNodeConfiguration*)itrNodeComposition.second;

        ouNodeConfig->GetCompositeNodes(lstCompNodes);
        std::ostringstream omCompositeNodes;
for(auto itrCompositeNode : lstCompNodes )
        {
            if(EC_SUCCESS == m_ouCluster->GetElement(eEcuElement, itrCompositeNode.m_uidNode, (IElement**)&pEcu) )
            {
                pEcu->GetName(omEcuName);
            }
            std::string omLogicalNodes = EMPTY_STRING;
            if(itrCompositeNode.m_strLogicalNodes.size() > 0)
            {
                auto itrLogicalNode = itrCompositeNode.m_strLogicalNodes.begin();
                omLogicalNodes = *itrLogicalNode;
                itrLogicalNode++;
                while(itrLogicalNode != itrCompositeNode.m_strLogicalNodes.end())
                {
                    omLogicalNodes += defCOMMA + *itrLogicalNode;
                    itrLogicalNode++;
                }
                omCompositeNodes << endl << defTWOTAB << omEcuName.c_str() << defOPEN_BRACE << endl << defTWOTAB << defTAB
                                 << omLogicalNodes.c_str() << endl << defTWOTAB << defCLOSE_BRACE;
            }
        }
        std::string omNodeConfigName;
        itrNodeComposition.second->GetName(omNodeConfigName);
        omNodeConfiguration << defTAB << defNODE_CONFIGURATION << omNodeConfigName.c_str()
                            << defOPEN_BRACE << omCompositeNodes.str() << endl << defTAB << defCLOSE_BRACE << endl ;
    }
    if(omNodeConfiguration.str().empty() == false)
    {
        m_omFileStream << defNODE_COMPOSITION << defOPEN_BRACE << endl << omNodeConfiguration.str() << defCLOSE_BRACE << endl;
    }
    return EC_SUCCESS;
}
void UnconditionalFrameEditDlg::vPopulatePublishers()
{
    std::string strECUName;
    std::map<UID_ELEMENT, IElement*> mapECUs;
    m_pouLDFCluster->GetElementList(eEcuElement, mapECUs);
    ui.comboPublisher->addItem(defNONE);
    QVariant qVar;
    // Populating Publishers
    for(auto itrECU : mapECUs)
    {
        IEcu* pEcu =  (IEcu*)(itrECU.second);
        strECUName = "";
        // Adding Publishers
        pEcu->GetName(strECUName);
        qVar.setValue(pEcu->GetUniqueId());
        ui.comboPublisher->addItem(QString::fromStdString(strECUName), qVar);
    }
}
void UnconditionalFrameEditDlg::vAddSubscribers(std::list<IEcu*> lstRxECUs)
{
    ui.listSubscribers->clear();
    std::map<std::string, std::string> maSubscribers;
    std::string strECUName;
    // Adding ECUs to Publisherlst and Subscriberlst
    maSubscribers.clear();
    for(auto itrECU : lstRxECUs)
    {
        IEcu* pEcu =  (IEcu*)(itrECU);
        strECUName = "";
        // Adding Publishers
        pEcu->GetName(strECUName);
        if(maSubscribers.find(strECUName) == maSubscribers.end())
        {
            // Adding Subscribers
            QListWidgetItem* item = new QListWidgetItem(QString::fromStdString(strECUName), ui.listSubscribers);
            item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
            ui.listSubscribers->addItem(item);
            maSubscribers[strECUName] = strECUName;
        }
    }
}
void UnconditionalFrameEditDlg::vUpdateEditFrameDetails()
{
    LinFrameProps ouFrameProps;
    ouFrameProps.m_eLinFrameType = eLinInvalidFrame;
    UID_ELEMENT uidFrame;
    IFrame* pFrame = *m_pouFrame;
    uidFrame = pFrame->GetUniqueId();
    pFrame->GetProperties(ouFrameProps);

    //2. Set Frame Props

    ouFrameProps.m_unMsgSize = GetUnsignedInt(ui.comboFrameLength->currentText(), 10);
    ouFrameProps.m_nMsgId = GetUnsignedInt(ui.comboFrameId->currentText());
    ouFrameProps.m_eLinFrameType = eLinUnconditionalFrame;

    pFrame->SetProperties(ouFrameProps);

    std::list<IEcu*> lstECUs;
    pFrame->GetEcus(eTx, lstECUs);

    UID_ELEMENT uidECU;
    for(auto itrECU : lstECUs)
    {
        uidECU = itrECU->GetUniqueId();
        itrECU->UnMapFrame(eTx, uidFrame);
        pFrame->UnMapNode(eTx, uidECU);
    }
    lstECUs.clear();

    for(auto itrECU : m_ouRxEcus)
    {
        uidECU = itrECU->GetUniqueId();
        itrECU->UnMapFrame(eRx, uidFrame);
        pFrame->UnMapNode(eRx, uidECU);
    }

    //3. Map Tx ECU and Map Tx Frame to Ecu
    IEcu* pouEcu = nullptr;
    UID_ELEMENT unEcuID = INVALID_UID_ELEMENT;
    std::string strPublisher = ui.comboPublisher->currentText().toStdString();
    m_pouLDFCluster->GetEcu(strPublisher, &pouEcu);
    if ( pouEcu != nullptr )
    {
        pouEcu->GetUniqueId(unEcuID);
        pFrame->MapNode(eTx, unEcuID);
        pouEcu->MapFrame(eTx, uidFrame);
    }

    //4. Map Signals and Map RX frames TO ecu




    SignalInstanse ouSignalInstance;
    ouSignalInstance.m_nStartBit = INVALID_DATA;
    ouSignalInstance.m_nUpdateBitPos = INVALID_DATA;
    ISignal* pSignal = nullptr;
    std::list<IEcu*> ecuList;
    UID_ELEMENT uidSignal;
    for( unsigned int unIndex = 0; unIndex < ui.tableSignals->rowCount(); unIndex++)
    {
        //QTreeWidgetItem *treeItem = ui.treeSignals->topLevelItem(unIndex);
        uidSignal = ui.tableSignals->item(unIndex, 0)->data(Qt::UserRole).value<UID_ELEMENT>();
        m_pouLDFCluster->GetElement(eSignalElement, uidSignal,  (IElement**)&pSignal);

        ecuList.clear();

        if(nullptr != pSignal)
        {
            pSignal->GetEcus(eTx, ecuList);
        }

        //Ldf contains one Ecu so take First Ecu only;
        auto itrTxEcu =  ecuList.begin();

        if ( itrTxEcu != ecuList.end() )
        {
            UID_ELEMENT unTempEcuId = INVALID_UID_ELEMENT;
            (*itrTxEcu)->GetUniqueId(unTempEcuId);
            if ( unTempEcuId == unEcuID )
            {
                ouSignalInstance.m_nStartBit = GetUnsignedInt(ui.tableSignals->item(unIndex, 1)->text(), 10);
                pFrame->MapSignal(uidSignal, ouSignalInstance);
                ecuList.clear();
                if(nullptr != pSignal)
                {
                    pSignal->GetEcus(eRx, ecuList);
                }
                for ( auto itrEcu : ecuList )
                {
                    itrEcu->MapFrame(eRx, uidFrame);
                }
            }
        }
    }

    //1. Set Frame Name
    pFrame->SetName(ui.editFrameName->text().toStdString());

}
void UnconditionalFrameEditDlg::vUpdateNewFrameDetails()
{
    FrameProps ouFrameProps;
    UID_ELEMENT uidFrame;
    IFrame* pFrame = nullptr;
    m_pouLDFCluster->CreateElement(eFrameElement, (IElement**)&pFrame);


    //2. Set Frame Props
    unsigned int nLength = GetUnsignedInt(ui.comboFrameLength->currentText(), 10);      //Always Dec
    ouFrameProps.m_ouLINUnConditionFrameProps.m_nLength = nLength;
    ouFrameProps.m_ouLINUnConditionFrameProps.m_unId = GetUnsignedInt(ui.comboFrameId->currentText());
    ouFrameProps.m_eFrameType = eLIN_Unconditional;

    pFrame->SetProperties(ouFrameProps);

    //3. Map Tx ECU and Map Tx Frame to Ecu
    IEcu* pouEcu = nullptr;
    UID_ELEMENT unEcuID = INVALID_UID_ELEMENT;
    m_pouLDFCluster->GetEcu(ui.comboPublisher->currentText().toStdString(), &pouEcu);
    if ( pouEcu != nullptr )
    {
        pouEcu->GetUniqueId(unEcuID);
        pFrame->MapNode(eTx, unEcuID);
        uidFrame = pFrame->GetUniqueId();
        pouEcu->MapFrame(eTx, uidFrame);
    }

    //4. Map Signals and Map RX frames TO ecu
    SignalInstanse ouSignalInstance;
    ISignal* pSignal = nullptr;
    std::list<IEcu*> ecuList;
    UID_ELEMENT uidSignal;
    for( unsigned int unIndex = 0; unIndex < ui.tableSignals->rowCount(); unIndex++)
    {
        //QTreeWidgetItem *treeItem = ui.treeSignals->topLevelItem(unIndex);
        uidSignal = ui.tableSignals->item(unIndex, 0)->data(Qt::UserRole).value<UID_ELEMENT>();
        m_pouLDFCluster->GetElement(eSignalElement, uidSignal,  (IElement**)&pSignal);

        ecuList.clear();
        if(nullptr != pSignal)
        {
            pSignal->GetEcus(eTx, ecuList);
        }

        //Ldf contains one Ecu so take First Ecu only;
        auto itrTxEcu =  ecuList.begin();
        if ( itrTxEcu != ecuList.end() )
        {
            UID_ELEMENT unTempEcuId = INVALID_UID_ELEMENT;
            (*itrTxEcu)->GetUniqueId(unTempEcuId);
            if ( unTempEcuId == unEcuID )
            {
                unsigned int unStartBit = GetUnsignedInt(ui.tableSignals->item(unIndex, 1)->text(), 10);
                ouSignalInstance.m_nStartBit =unStartBit;
                //ouSignalInstance.m_nStartBit = treeItem->text(1).toInt();
                pFrame->MapSignal(uidSignal, ouSignalInstance);
                ecuList.clear();
                if(nullptr != pSignal)
                {
                    pSignal->GetEcus(eRx, ecuList);
                }
for ( auto itrEcu : ecuList )
                {
                    itrEcu->MapFrame(eRx, uidFrame);
                }
            }
        }
    }
    //1. Set Frame Name
    pFrame->SetName(ui.editFrameName->text().toStdString());

    *m_pouFrame = pFrame;
}
ERRORCODE CCommonLDFGenerator::nGenerateScheduleItem(CSheduleTableItem omShceduleItem, ostringstream& omSchedItemStream)
{
    IFrame* pFrame = nullptr;

    m_ouCluster->GetElement(eFrameElement, omShceduleItem.m_nFrameId, (IElement**)&pFrame);

    std::string strFrameName, strEcuName, strLDFVersion;
    std::ostringstream omStream, omPIDs;

    if(nullptr != pFrame)
    {
        pFrame->GetName(strFrameName);
    }
    IEcu* pECU = nullptr;

    if(omShceduleItem.m_nNode != INVALID_UID_ELEMENT)
    {
        m_ouCluster->GetElement(eEcuElement, omShceduleItem.m_nNode, (IElement**)&pECU);

        if(nullptr != pECU)
        {
            pECU->GetName(strEcuName);
        }
    }

    UID_ELEMENT idFrame;
    LIN_Settings ouSettings;
    m_ouCluster->GetProperties(eLINClusterProperties, &ouSettings);
    nGetLDFVersion(ouSettings.m_dProtocolVers, strLDFVersion);

    switch (omShceduleItem.m_eDiagType)
    {
        case eLIN_NORMAL_FRAME_ID:
            omSchedItemStream << defTAB << strFrameName.c_str() << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_MASTER_FRAME_ID:
            omSchedItemStream << defTAB << defMASTER_REQUEST << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SLAVE_FRAME_ID:
            omSchedItemStream << defTAB << defSLAVE_RESP << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SID_ASSIGN_NAD_ID:
            if(strLDFVersion == defLIN_VERSION_2_0)
            {
                omSchedItemStream << defTAB << defASSIGN_NAD << defOPEN_BRACE
                                  << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[0] << defCOMMA
                                  << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[7] << defCOMMA
                                  << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[3] << defCOMMA
                                  << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[5]
                                  <<  defCLOSE_BRACE
                                  << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            }
            else if(strLDFVersion == defLIN_VERSION_2_1)
            {
                omSchedItemStream << defTAB << defASSIGN_NAD << defOPEN_BRACE <<  strEcuName.c_str() << defCLOSE_BRACE
                                  << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            }
            break;
        case eLIN_SID_COND_CHANGE_NAD:
            omSchedItemStream << defTAB << defCONDITIONALCHANGENAD << defOPEN_BRACE
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[0] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[3] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[4] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[5] << defCOMMA
                              << defHEX << std::hex <<std::uppercase <<  (int)omShceduleItem.m_chDataBytes[6] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[7]
                              << defCLOSE_BRACE << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SID_DATA_DUMP:
            omSchedItemStream << defTAB << defDATADUMP << defOPEN_BRACE << strEcuName.c_str() << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[3] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[4] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[5] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[6] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[7] << defCLOSE_BRACE
                              << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SID_SAVE_CONFIG:
            omSchedItemStream << defTAB << defSAVECONFIG << defOPEN_BRACE <<  strEcuName.c_str() << defCLOSE_BRACE
                              << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SID_ASSIGN_FRAME_RANGE:

            nGetFramePIDs(omShceduleItem, omPIDs);
            omSchedItemStream << defTAB << defASSIGN_FRAMEID_RANGE << defOPEN_BRACE << strEcuName.c_str() << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)( omShceduleItem.m_chDataBytes[3] )<<  omPIDs.str() << defCLOSE_BRACE
                              << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SID_FREEFORMAT:
            omSchedItemStream << defTAB << defFREEFORMAT << defOPEN_BRACE
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[0] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[1] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[2] << defCOMMA
                              << defHEX << std::hex <<std::uppercase  << (int)omShceduleItem.m_chDataBytes[3]<< defCOMMA
                              << defHEX << std::hex <<std::uppercase <<  (int)omShceduleItem.m_chDataBytes[4] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[5]  << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[6] << defCOMMA
                              << defHEX << std::hex <<std::uppercase <<  (int)omShceduleItem.m_chDataBytes[7] <<  defCLOSE_BRACE
                              << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SID_READ_BY_IDENTIFIER:
            omSchedItemStream << defTAB << defFREEFORMAT << defOPEN_BRACE << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[0]
                              << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[1] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[2] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[3] << defCOMMA
                              << defHEX << std::hex <<std::uppercase <<  (int)omShceduleItem.m_chDataBytes[4] << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[5]  << defCOMMA
                              << defHEX << std::hex <<std::uppercase << (int)omShceduleItem.m_chDataBytes[6]  << defCOMMA
                              << defHEX << std::hex <<std::uppercase <<  (int)omShceduleItem.m_chDataBytes[7] <<  defCLOSE_BRACE
                              << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SID_ASSIGN_FRAME_ID:
            idFrame = omShceduleItem.m_chDataBytes[7];
            m_ouCluster->GetElement(eFrameElement, idFrame, (IElement**)&pFrame);

            if(nullptr != pFrame)
            {
                pFrame->GetName(strFrameName);
            }
            omSchedItemStream << defTAB << defASSIGNFRAMEID << defOPEN_BRACE << strEcuName.c_str() << defCOMMA << strFrameName.c_str() << defCLOSE_BRACE
                              << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        case eLIN_SID_UNASSIGN_FRAME_ID:
            idFrame = omShceduleItem.m_chDataBytes[7];
            m_ouCluster->GetElement(eFrameElement, idFrame, (IElement**)&pFrame);

            if(nullptr != pFrame)
            {
                pFrame->GetName(strFrameName);
            }
            omSchedItemStream << defTAB << defUNASSIGNFRAMEID << defOPEN_BRACE << strEcuName.c_str() << defCOMMA << strFrameName.c_str() << defCLOSE_BRACE
                              << defDELAY << omShceduleItem.m_dDelay << defUNIT_MS << defSEMICOLON;
            break;
        default:
            break;
    }
    return EC_SUCCESS;
}
int LDFEditor::nValidateForCluster(list<ParsingResults>& ouErrors, list<ParsingResults>& ouWarnings)
{
    //1. Ecu Validations
    std::map<UID_ELEMENT, IElement*> pElement;

    LDFDatabaseManager::GetDatabaseManager()->GetLDFCluster()->GetElementList(eEcuElement, pElement);
    bool bMasterFound = false;
    bool bSlaveFound = false;
	LinEcuProps ecuProps;
for ( auto itr : pElement )
    {
        IEcu* pEcu = (IEcu*)itr.second;
        if ( nullptr == pEcu )
        {
            continue;
        }

		pEcu->GetProperties(ecuProps);
		if (ecuProps.m_eEcuType == eMaster)
        {
            bMasterFound = true;
        }
		else if (ecuProps.m_eEcuType == eSlave)
        {
            bSlaveFound = true;
        }
    }

    if ( false == bMasterFound )
    {
        ParsingResults ouPasringResult;
        ouPasringResult.m_ouErrorType = eError;
        ouPasringResult.m_strActionTaken = "";
        ouPasringResult.m_strErrorDesc = "Master ECU should be defined in LDF File";
        ouPasringResult.m_unErrorCode = 1;
        ouPasringResult.m_unLineNum = 0;
        ouErrors.push_back(ouPasringResult);
    }
    if ( false == bSlaveFound )
    {
        ParsingResults ouPasringResult;
        ouPasringResult.m_ouErrorType = eError;
        ouPasringResult.m_strActionTaken = "";
        ouPasringResult.m_strErrorDesc = "Atleast One Slave should be Defined in LDF File";
        ouPasringResult.m_unErrorCode = 1;
        ouPasringResult.m_unLineNum = 0;
        ouErrors.push_back(ouPasringResult);
    }


    //2. UnCondition Frames
    bool bUnconditionalFrameFound = false;;
    pElement.clear();
    LDFDatabaseManager::GetDatabaseManager()->GetLDFCluster()->GetElementList(eFrameElement, pElement);
	LinFrameProps frameProps;
for ( auto itr : pElement )
    {
        IFrame* pFrame = (IFrame*)itr.second;
        if ( nullptr == pFrame )
        {
            continue;
        }

		pFrame->GetProperties(frameProps);
		if (frameProps.m_eLinFrameType == eLinUnconditionalFrame)
        {
            bUnconditionalFrameFound = true;
            break;
        }
    }
    if ( false == bUnconditionalFrameFound )
    {
        ParsingResults ouPasringResult;
        ouPasringResult.m_ouErrorType = eWarning;
        ouPasringResult.m_strActionTaken = "";
        ouPasringResult.m_strErrorDesc = "Valid LDF File should Contain Atleast one Unconditional Frame";
        ouPasringResult.m_unErrorCode = 1;
        ouPasringResult.m_unLineNum = 0;
        ouWarnings.push_back(ouPasringResult);
    }

    //3. Signals
    bool SignalFound = false;
    pElement.clear();
    LDFDatabaseManager::GetDatabaseManager()->GetLDFCluster()->GetElementList(eSignalElement, pElement);
	LINSignalProps ouSignalProps;
for ( auto itr : pElement )
    {
        ISignal* pSignal = (ISignal*)itr.second;
        if ( nullptr == pSignal )
        {
            continue;
        }

        pSignal->GetProperties(ouSignalProps);
        if ( ouSignalProps.m_ouSignalType == eSignalNormal )
        {
            SignalFound = true;
            break;
        }
    }
    if ( false == SignalFound )
    {
        ParsingResults ouPasringResult;
        ouPasringResult.m_ouErrorType = eWarning;
        ouPasringResult.m_strActionTaken = "";
        ouPasringResult.m_strErrorDesc = "Valid LDF File should Contain Atleast one signal";
        ouPasringResult.m_unErrorCode = 1;
        ouPasringResult.m_unLineNum = 0;
        ouWarnings.push_back(ouPasringResult);
    }

    //4. Tables
    bool TableFound = false;
    pElement.clear();
    LDFDatabaseManager::GetDatabaseManager()->GetLDFCluster()->GetElementList(eScheduleTableElement, pElement);
for ( auto itr : pElement )
    {
        ScheduleTableProps ouTableProps;
        IScheduleTable* pTable = (IScheduleTable*)itr.second;

        if ( nullptr == pTable )
        {
            continue;
        }
        pTable->GetProperties(ouTableProps);

        if ( ouTableProps.m_ouCLINSheduleTableItem.size() > 0 )
        {
            TableFound = true;
            break;
        }
    }
    if ( false == TableFound )
    {
        ParsingResults ouPasringResult;
        ouPasringResult.m_ouErrorType = eWarning;
        ouPasringResult.m_strActionTaken = "";
        ouPasringResult.m_strErrorDesc = "Valid LDF File should Contain Atleast one Schedule Table";
        ouPasringResult.m_unErrorCode = 1;
        ouPasringResult.m_unLineNum = 0;
        ouWarnings.push_back(ouPasringResult);
    }
    return 0;
}