//---------------------------------------------------------------------------- // EgalTech 2017-2017 //---------------------------------------------------------------------------- // File : ChiselingData.cpp Data : 03.02.17 Versione : 1.8b1 // Contenuto : Implementazione struttura dati lavorazione di foratura. // // // // Modifiche : 03.02.17 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "ChiselingData.h" #include "MachiningDataFactory.h" #include "MachiningConst.h" #include "/EgtDev/Include/EmkToolConst.h" #include "/EgtDev/Include/EmkSimuGenConst.h" #include "/EgtDev/Include/EGnStringUtils.h" #include #include using namespace std ; //---------------------------------------------------------------------------- enum nChiselingKey { KEY_AB = 0, KEY_AI, KEY_DH, KEY_EAL, KEY_F, KEY_FE, KEY_FT, KEY_INV, KEY_NAME, KEY_NNS, KEY_NNU, KEY_OL, KEY_OR, KEY_PR, KEY_PS, KEY_SCC, KEY_ST, KEY_TI, KEY_TNAME, KEY_TUUID, KEY_UUID, KEY_WS, KEY_ZZZ} ; // rappresenta il numero di elementi static const array sChiselingKey = { "AB", "AI", "DH", "EAL", "F", "FE", "FT", "INV", "NAME", "NNS", "NNU", "OL", "OR", "PR", "PS", "SCC", "ST", "TI", "TN", "TU", "UUID", "WS"} ; //---------------------------------------------------------------------------- MCHDATA_REGISTER( MT_CHISELING, "CHISELING", ChiselingData) ; //---------------------------------------------------------------------------- ChiselingData* ChiselingData::Clone( void) const { // alloco oggetto ChiselingData* pDdata = new(nothrow) ChiselingData ; // copio i dati if ( pDdata != nullptr) { if ( ! pDdata->CopyFrom( this)) { delete pDdata ; return nullptr ; } } return pDdata ; } //---------------------------------------------------------------------------- bool ChiselingData::CopyFrom( const MachiningData* pMdata) { // è inutile copiare se sorgente coincide con destinazione if ( pMdata == this) return true ; // la sorgente deve essere dello stesso tipo const ChiselingData* pDdata = GetChiselingData( pMdata) ; if ( pDdata == nullptr) return false ; // eseguo copia m_Uuid = pDdata->m_Uuid ; m_sName = pDdata->m_sName ; m_ToolUuid = pDdata->m_ToolUuid ; m_sToolName = pDdata->m_sToolName ; m_sBlockedAxis = pDdata->m_sBlockedAxis ; m_sInitAngs = pDdata->m_sInitAngs ; m_nSolCh = pDdata->m_nSolCh ; m_dFeed = pDdata->m_dFeed ; m_dEndFeed = pDdata->m_dEndFeed ; m_dTipFeed = pDdata->m_dTipFeed ; m_dOffsL = pDdata->m_dOffsL ; m_dOffsR = pDdata->m_dOffsR ; m_nWorkSide = pDdata->m_nWorkSide ; m_bToolInvert = pDdata->m_bToolInvert ; m_bInvert = pDdata->m_bInvert ; m_sDepth = pDdata->m_sDepth ; m_dStartPos = pDdata->m_dStartPos ; m_dStep = pDdata->m_dStep ; m_dReturnPos = pDdata->m_dReturnPos ; m_dEndAddLen = pDdata->m_dEndAddLen ; m_sSysNotes = pDdata->m_sSysNotes ; m_sUserNotes = pDdata->m_sUserNotes ; return true ; } //---------------------------------------------------------------------------- bool ChiselingData::SameAs(const MachiningData* pMdata) const { // se coincide con altro -> uguali if ( pMdata == this) return true ; // se sono di tipo diverso -> diversi const ChiselingData* pDdata = GetChiselingData( pMdata) ; if ( pDdata == nullptr) return false ; // confronto termine a termine return ( m_Uuid == pDdata->m_Uuid && m_sName == pDdata->m_sName && m_ToolUuid == pDdata->m_ToolUuid && m_sToolName == pDdata->m_sToolName && m_sBlockedAxis == pDdata->m_sBlockedAxis && m_sInitAngs == pDdata->m_sInitAngs && m_nSolCh == pDdata->m_nSolCh && abs( m_dFeed - pDdata->m_dFeed) < EPS_MACH_LEN_PAR && abs( m_dEndFeed - pDdata->m_dEndFeed) < EPS_MACH_LEN_PAR && abs( m_dTipFeed - pDdata->m_dTipFeed) < EPS_MACH_LEN_PAR && abs( m_dOffsL - pDdata->m_dOffsL) < EPS_MACH_LEN_PAR && abs( m_dOffsR - pDdata->m_dOffsR) < EPS_MACH_LEN_PAR && m_nWorkSide == pDdata->m_nWorkSide && m_bToolInvert == pDdata->m_bToolInvert && m_bInvert == pDdata->m_bInvert && m_sDepth == pDdata->m_sDepth && abs( m_dStartPos - pDdata->m_dStartPos) < EPS_MACH_LEN_PAR && abs( m_dStep - pDdata->m_dStep) < EPS_MACH_LEN_PAR && abs( m_dReturnPos - pDdata->m_dReturnPos) < EPS_MACH_LEN_PAR && abs( m_dEndAddLen - pDdata->m_dEndAddLen) < EPS_MACH_LEN_PAR && m_sSysNotes == pDdata->m_sSysNotes && m_sUserNotes == pDdata->m_sUserNotes) ; } //---------------------------------------------------------------------------- int ChiselingData::GetSize( void) const { // in debug verifico validità ultimo campo assert( sChiselingKey[KEY_UUID] == "UUID") ; return KEY_ZZZ ; } //---------------------------------------------------------------------------- string ChiselingData::GetTitle( void) const { return MCHDATA_GETNAME( ChiselingData) ; } //---------------------------------------------------------------------------- int FindChiselingKey( const string& sKey) { auto TheRange = equal_range( sChiselingKey.cbegin(), sChiselingKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sChiselingKey.cbegin()) ; } //---------------------------------------------------------------------------- bool ChiselingData::FromString( const string& sString, int& nKey) { // separo chiave da valore string sKey, sVal ; SplitFirst( sString, "=", sKey, sVal) ; // riconosco la chiave nKey = FindChiselingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { case KEY_AB : m_sBlockedAxis = sVal ; break ; case KEY_AI : m_sInitAngs = sVal ; break ; case KEY_DH : m_sDepth = sVal ; if ( m_sDepth.empty()) m_sDepth = "TH" ; break ; case KEY_EAL : bOk = ::FromString( sVal, m_dEndAddLen) ; break ; case KEY_F : bOk = ::FromString( sVal, m_dFeed) ; break ; case KEY_FE : bOk = ::FromString( sVal, m_dEndFeed) ; break ; case KEY_FT : bOk = ::FromString( sVal, m_dTipFeed) ; break ; case KEY_INV : bOk = ::FromString( sVal, m_bInvert) ; break ; case KEY_NAME : m_sName = sVal ; bOk = ! m_sName.empty() ; break ; case KEY_NNS : m_sSysNotes = sVal ; break ; case KEY_NNU : m_sUserNotes = sVal ; break ; case KEY_OL : bOk = ::FromString( sVal, m_dOffsL) ; break ; case KEY_OR : bOk = ::FromString( sVal, m_dOffsR) ; break ; case KEY_PR : bOk = ::FromString( sVal, m_dReturnPos) ; break ; case KEY_PS : bOk = ::FromString( sVal, m_dStartPos) ; break ; case KEY_SCC : bOk = ::FromString( sVal, m_nSolCh) ; break ; case KEY_ST : bOk = ::FromString( sVal, m_dStep) ; break ; case KEY_TI : bOk = ::FromString( sVal, m_bToolInvert) ; break ; case KEY_TNAME : m_sToolName = sVal ; break ; case KEY_TUUID : bOk = ::FromString( sVal, m_ToolUuid) ; break ; case KEY_UUID : bOk = ::FromString( sVal, m_Uuid) ; break ; case KEY_WS : bOk = ::FromString( sVal, m_nWorkSide) ; break ; default : bOk = false ; break ; } return bOk ; } //---------------------------------------------------------------------------- string ChiselingData::ToString( int nKey) const { switch ( nKey) { case KEY_AB : return ( sChiselingKey[KEY_AB] + "=" + m_sBlockedAxis) ; case KEY_AI : return ( sChiselingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_DH : return ( sChiselingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_EAL : return ( sChiselingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; case KEY_F : return ( sChiselingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; case KEY_FE : return ( sChiselingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ; case KEY_FT : return ( sChiselingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ; case KEY_INV : return ( sChiselingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; case KEY_NAME : return ( sChiselingKey[KEY_NAME] + "=" + m_sName) ; case KEY_NNS : return ( sChiselingKey[KEY_NNS] + "=" + m_sSysNotes) ; case KEY_NNU : return ( sChiselingKey[KEY_NNU] + "=" + m_sUserNotes) ; case KEY_OL : return ( sChiselingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ; case KEY_OR : return ( sChiselingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ; case KEY_PR : return ( sChiselingKey[KEY_PR] + "=" + ::ToString( m_dReturnPos)) ; case KEY_PS : return ( sChiselingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ; case KEY_SCC : return ( sChiselingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ; case KEY_ST : return ( sChiselingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ; case KEY_TI : return ( sChiselingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ; case KEY_TNAME : return ( sChiselingKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sChiselingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; case KEY_UUID : return ( sChiselingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; case KEY_WS : return ( sChiselingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ; default : return "" ; } } //---------------------------------------------------------------------------- bool ChiselingData::IsOptional( int nKey) const { return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_TI) ; } //---------------------------------------------------------------------------- bool ChiselingData::VerifySolCh( int nVal) const { return IsValidOperationScc( nVal) ; } //---------------------------------------------------------------------------- bool ChiselingData::VerifyWorkSide( int nVal) const { return ( nVal == CHISEL_WS_LEFT || nVal == CHISEL_WS_RIGHT) ; } //---------------------------------------------------------------------------- bool ChiselingData::VerifyTool( const ToolsMgr* pToolsMgr, const string& sVal, const ToolData*& pTdata) const { if ( pToolsMgr == nullptr) return false ; pTdata = pToolsMgr->GetTool( sVal) ; if ( pTdata == nullptr) return false ; if ( pTdata->m_nType != TT_CHISEL_STD) return false ; return true ; } //---------------------------------------------------------------------------- bool ChiselingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const { if ( pToolsMgr == nullptr) return false ; pTdata = pToolsMgr->GetTool( m_ToolUuid) ; return ( pTdata != nullptr) ; } //---------------------------------------------------------------------------- bool ChiselingData::SetParam( int nType, bool bVal) { switch ( nType) { case MPA_INVERT : m_bInvert = bVal ; return true ; case MPA_TOOLINVERT : m_bToolInvert = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool ChiselingData::SetParam( int nType, int nVal) { switch ( nType) { case MPA_WORKSIDE : if ( ! VerifyWorkSide( nVal)) return false ; m_nWorkSide = nVal ; return true ; case MPA_SCC : if ( ! VerifySolCh( nVal)) return false ; m_nSolCh = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool ChiselingData::SetParam( int nType, double dVal) { switch ( nType) { case MPA_FEED : m_dFeed = dVal ; return true ; case MPA_ENDFEED : m_dEndFeed = dVal ; return true ; case MPA_TIPFEED : m_dTipFeed = dVal ; return true ; case MPA_OFFSL : m_dOffsL = dVal ; return true ; case MPA_OFFSR : m_dOffsR = dVal ; return true ; case MPA_DEPTH : m_sDepth = ::ToString( dVal) ; return true ; case MPA_STARTPOS : m_dStartPos = dVal ; return true ; case MPA_STEP : m_dStep = dVal ; return true ; case MPA_RETURNPOS : m_dReturnPos = dVal ; return true ; case MPA_ENDADDLEN : m_dEndAddLen = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool ChiselingData::SetParam( int nType, const string& sVal) { switch ( nType) { case MPA_NAME : m_sName = sVal ; return true ; case MPA_TOOL : m_sToolName = sVal ; return true ; case MPA_DEPTH_STR : m_sDepth = sVal ; return true ; case MPA_TUUID : return ::FromString( sVal, m_ToolUuid) ; case MPA_UUID : return ::FromString( sVal, m_Uuid) ; case MPA_SYSNOTES : m_sSysNotes = sVal ; return true ; case MPA_USERNOTES : m_sUserNotes = sVal ; return true ; case MPA_INITANGS : m_sInitAngs = sVal ; return true ; case MPA_BLOCKEDAXIS : m_sBlockedAxis = sVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool ChiselingData::ResetTool( void) { m_sToolName.clear() ; m_ToolUuid.Clear() ; return true ; } //---------------------------------------------------------------------------- bool ChiselingData::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_bInvert ; return true ; case MPA_TOOLINVERT : bVal = m_bToolInvert ; return true ; } bVal = false ; return false ; } //---------------------------------------------------------------------------- bool ChiselingData::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_CHISELING ; return true ; case MPA_WORKSIDE : nVal = m_nWorkSide ; return true ; case MPA_SCC : nVal = m_nSolCh ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool ChiselingData::GetParam( int nType, double& dVal) const { switch ( nType) { case MPA_FEED : dVal = m_dFeed ; return true ; case MPA_ENDFEED : dVal = m_dEndFeed ; return true ; case MPA_TIPFEED : dVal = m_dTipFeed ; return true ; case MPA_OFFSL : dVal = m_dOffsL ; return true ; case MPA_OFFSR : dVal = m_dOffsR ; return true ; case MPA_STARTPOS : dVal = m_dStartPos ; return true ; case MPA_STEP : dVal = m_dStep ; return true ; case MPA_RETURNPOS : dVal = m_dReturnPos ; return true ; case MPA_ENDADDLEN : dVal = m_dEndAddLen ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool ChiselingData::GetParam( int nType, string& sVal) const { switch ( nType) { case MPA_NAME : sVal = m_sName ; return true ; case MPA_TOOL : sVal = m_sToolName ; return true ; case MPA_DEPTH_STR : sVal = m_sDepth ; return true ; case MPA_TUUID : sVal = ::ToString( m_ToolUuid) ; return true ; case MPA_UUID : sVal = ::ToString( m_Uuid) ; return true ; case MPA_SYSNOTES : sVal = m_sSysNotes ; return true ; case MPA_USERNOTES : sVal = m_sUserNotes ; return true ; case MPA_INITANGS : sVal = m_sInitAngs ; return true ; case MPA_BLOCKEDAXIS : sVal = m_sBlockedAxis ; return true ; } sVal = "" ; return false ; }