//---------------------------------------------------------------------------- // EgalTech 2015-2015 //---------------------------------------------------------------------------- // File : SawingData.cpp Data : 05.06.15 Versione : 1.6f1 // Contenuto : Implementazione struttura dati lavorazione di taglio di lama. // // // // Modifiche : 05.06.15 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "SawingData.h" #include "MachiningDataFactory.h" #include "/EgtDev/Include/EmkToolConst.h" #include "/EgtDev/Include/EGkGeoConst.h" #include "/EgtDev/Include/EGnStringUtils.h" #include #include using namespace std ; //---------------------------------------------------------------------------- enum nSawingKey { KEY_APPR = 0, KEY_CRV, KEY_DH, KEY_HS, KEY_INV, KEY_LETY, KEY_LITY, KEY_LOTY, KEY_NAME, KEY_SA, KEY_TAF, KEY_TNAME, KEY_TUUID, KEY_UUID, KEY_WS, KEY_ZZZ} ; // rappresenta il numero di elementi static const std::array sSawingKey = { "APPR", "CRV", "DH", "HS", "INV", "LETY", "LITY", "LOTY", "NAME", "SA", "TAF", "TN", "TU", "UUID", "WS"} ; //---------------------------------------------------------------------------- MCHDATA_REGISTER( MT_SAWING, "SAWING", SawingData) ; //---------------------------------------------------------------------------- SawingData* SawingData::Clone( void) const { // alloco oggetto SawingData* pSdata = new(nothrow) SawingData ; // copio i dati if ( pSdata != nullptr) { if ( ! pSdata->CopyFrom( this)) { delete pSdata ; return nullptr ; } } return pSdata ; } //---------------------------------------------------------------------------- bool SawingData::CopyFrom( const MachiningData* pMdata) { // è inutile copiare se sorgente coincide con destinazione if ( pMdata == this) return true ; // la sorgente deve essere dello stesso tipo const SawingData* pSdata = dynamic_cast( pMdata) ; if ( pSdata == nullptr) return false ; // eseguo copia m_Uuid = pSdata->m_Uuid ; m_sName = pSdata->m_sName ; m_ToolUuid = pSdata->m_ToolUuid ; m_sToolName = pSdata->m_sToolName ; m_bInvert = pSdata->m_bInvert ; m_nWorkSide = pSdata->m_nWorkSide ; m_nHeadSide = pSdata->m_nHeadSide ; m_bToAndFrom = pSdata->m_bToAndFrom ; m_sDepth = pSdata->m_sDepth ; m_dSideAngle = pSdata->m_dSideAngle ; m_nLeadInType = pSdata->m_nLeadInType ; m_nExtLinkType = pSdata->m_nExtLinkType ; m_nLeadOutType = pSdata->m_nLeadOutType ; m_nCurveUse = pSdata->m_nCurveUse ; m_dApprox = pSdata->m_dApprox ; return true ; } //---------------------------------------------------------------------------- bool SawingData::SameAs(const MachiningData* pMdata) const { // se coincide con altro -> uguali if ( pMdata == this) return true ; // se sono di tipo diverso -> diversi const SawingData* pSdata = dynamic_cast( pMdata) ; if ( pSdata == nullptr) return false ; // confronto termine a termine return ( m_Uuid == pSdata->m_Uuid && m_sName == pSdata->m_sName && m_ToolUuid == pSdata->m_ToolUuid && m_sToolName == pSdata->m_sToolName && m_bInvert == pSdata->m_bInvert && m_nWorkSide == pSdata->m_nWorkSide && m_nHeadSide == pSdata->m_nHeadSide && m_bToAndFrom == pSdata->m_bToAndFrom && m_sDepth == pSdata->m_sDepth && m_dSideAngle == pSdata->m_dSideAngle && m_nLeadInType == pSdata->m_nLeadInType && m_nExtLinkType == pSdata->m_nExtLinkType && m_nLeadOutType == pSdata->m_nLeadOutType && m_nCurveUse == pSdata->m_nCurveUse && m_dApprox == pSdata->m_dApprox) ; } //---------------------------------------------------------------------------- int SawingData::GetSize( void) const { // in debug verifico validità ultimo campo assert( sSawingKey[KEY_WS] == "WS") ; return KEY_ZZZ ; } //---------------------------------------------------------------------------- string SawingData::GetTitle( void) const { return MCHDATA_GETNAME( SawingData) ; } //---------------------------------------------------------------------------- int FindSawingKey( const string& sKey) { auto TheRange = equal_range( sSawingKey.cbegin(), sSawingKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sSawingKey.cbegin()) ; } //---------------------------------------------------------------------------- bool SawingData::FromString( const string& sString, int& nKey) { // separo chiave da valore string sKey, sVal ; SplitFirst( sString, "=", sKey, sVal) ; // riconosco la chiave nKey = FindSawingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { case KEY_APPR : bOk = ::FromString( sVal, m_dApprox) ; break ; case KEY_CRV : bOk = ::FromString( sVal, m_nCurveUse) ; break ; case KEY_DH : m_sDepth = sVal ; if ( m_sDepth.empty()) m_sDepth = "0" ; break ; case KEY_HS : bOk = ::FromString( sVal, m_nHeadSide) ; break ; case KEY_INV : bOk = ::FromString( sVal, m_bInvert) ; break ; case KEY_LETY : bOk = ::FromString( sVal, m_nExtLinkType) ; break ; case KEY_LITY : bOk = ::FromString( sVal, m_nLeadInType) ; break ; case KEY_LOTY : bOk = ::FromString( sVal, m_nLeadOutType) ; break ; case KEY_NAME : m_sName = sVal ; bOk = ! m_sName.empty() ; break ; case KEY_SA : bOk = ::FromString( sVal, m_dSideAngle) ; break ; case KEY_TAF : bOk = ::FromString( sVal, m_bToAndFrom) ; 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 SawingData::ToString( int nInd) const { switch ( nInd) { case KEY_APPR : return ( sSawingKey[KEY_APPR] + "=" + ::ToString( m_dApprox)) ; case KEY_CRV : return ( sSawingKey[KEY_CRV] + "=" + ::ToString( m_nCurveUse)) ; case KEY_DH : return ( sSawingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_HS : return ( sSawingKey[KEY_HS] + "=" + ::ToString( m_nHeadSide)) ; case KEY_INV : return ( sSawingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; case KEY_LETY : return ( sSawingKey[KEY_LETY] + "=" + ::ToString( m_nExtLinkType)) ; case KEY_LITY : return ( sSawingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ; case KEY_LOTY : return ( sSawingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ; case KEY_NAME : return ( sSawingKey[KEY_NAME] + "=" + m_sName) ; case KEY_SA : return ( sSawingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ; case KEY_TAF : return ( sSawingKey[KEY_TAF] + "=" + ::ToString( m_bToAndFrom)) ; case KEY_TNAME : return ( sSawingKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sSawingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; case KEY_UUID : return ( sSawingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; case KEY_WS : return ( sSawingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ; default : return "" ; } } //---------------------------------------------------------------------------- bool SawingData::VerifyWorkSide( int nVal) const { return ( nVal == SAW_WS_CENTER || nVal == SAW_WS_LEFT || nVal == SAW_WS_RIGHT) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyHeadSide( int nVal) const { return ( nVal == SAW_HS_LEFT || nVal == SAW_HS_RIGHT) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyLeadInType( int nVal) const { return ( nVal == SAW_LI_STRICT || nVal == SAW_LI_CENT || nVal == SAW_LI_OUT || nVal == SAW_LI_EXT_CENT || nVal == SAW_LI_EXT_OUT) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyExtLinkType( int nVal) const { return ( nVal == SAW_EL_CENT || nVal == SAW_EL_EXT_PREV || nVal == SAW_EL_EXT_NEXT || nVal == SAW_EL_EXT_BOTH) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyLeadOutType( int nVal) const { return ( nVal == SAW_LO_STRICT || nVal == SAW_LO_CENT || nVal == SAW_LO_EXT) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyCurveUse( int nVal) const { return ( nVal == SAW_CRV_SKIP || nVal == SAW_CRV_APPROX || nVal == SAW_CRV_CONVEX) ; } //---------------------------------------------------------------------------- bool SawingData::VerifySideAngle( double dVal) const { const double MAX_SIDE_ANG = 60 + EPS_ANG_SMALL ; const double AUTO_SIDE_ANG = 99 ; return ( ( dVal > - MAX_SIDE_ANG && dVal < MAX_SIDE_ANG) || fabs( dVal - AUTO_SIDE_ANG) < EPS_ANG_SMALL) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const { if ( pToolsMgr == nullptr) return false ; pTdata = pToolsMgr->GetTool( sVal) ; if ( pTdata == nullptr) return false ; if ( ( pTdata->m_nType & TF_SAWBLADE) == 0) return false ; return true ; } //---------------------------------------------------------------------------- bool SawingData::SetParam( int nType, bool bVal) { switch ( nType) { case MPA_INVERT : m_bInvert = bVal ; return true ; case MPA_TOANDFROM : m_bToAndFrom = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::SetParam( int nType, int nVal) { switch ( nType) { case MPA_WORKSIDE : if ( ! VerifyWorkSide( nVal)) return false ; m_nWorkSide = nVal ; return true ; case MPA_HEADSIDE : if ( ! VerifyHeadSide( nVal)) return false ; m_nHeadSide = nVal ; return true ; case MPA_LEADINTYPE : if ( ! VerifyLeadInType( nVal)) return false ; m_nLeadInType = nVal ; return true ; case MPA_EXTLINKTYPE : if ( ! VerifyExtLinkType( nVal)) return false ; m_nExtLinkType = nVal ; return true ; case MPA_LEADOUTTYPE : if ( ! VerifyLeadOutType( nVal)) return false ; m_nLeadOutType = nVal ; return true ; case MPA_CURVEUSE : if ( ! VerifyCurveUse( nVal)) return false ; m_nCurveUse = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::SetParam( int nType, double dVal) { switch ( nType) { case MPA_DEPTH : m_sDepth = ::ToString( dVal) ; return true ; case MPA_SIDEANGLE : if ( ! VerifySideAngle( dVal)) return false ; m_dSideAngle = dVal ; return true ; case MPA_APPROX : m_dApprox = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::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) ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_bInvert ; return true ; case MPA_TOANDFROM : bVal = m_bToAndFrom ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_WORKSIDE : nVal = m_nWorkSide ; return true ; case MPA_HEADSIDE : nVal = m_nHeadSide ; return true ; case MPA_LEADINTYPE : nVal = m_nLeadInType ; return true ; case MPA_EXTLINKTYPE : nVal = m_nExtLinkType ; return true ; case MPA_LEADOUTTYPE : nVal = m_nLeadOutType ; return true ; case MPA_CURVEUSE : nVal = m_nCurveUse ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::GetParam( int nType, double& dVal) const { switch ( nType) { case MPA_SIDEANGLE : dVal = m_dSideAngle ; return true ; case MPA_APPROX : dVal = m_dApprox ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::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 ; } return false ; }