EgtMachKernel/SawingData.cpp

//----------------------------------------------------------------------------
//  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 "MachiningConst.h"
#include "/EgtDev/Include/EmkToolConst.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include <array>
#include <cassert>

using namespace std ;

//----------------------------------------------------------------------------
enum nSawingKey {
   KEY_APPR = 0,
   KEY_CRV,
   KEY_DH,
   KEY_EAL,
   KEY_HS,
   KEY_INV,
   KEY_LETY,
   KEY_LITY,
   KEY_LOTY,
   KEY_NAME,
   KEY_NNS,
   KEY_NNU,
   KEY_PS,
   KEY_SA,
   KEY_SAL,
   KEY_ST,
   KEY_STEA,
   KEY_STIA,
   KEY_STY,
   KEY_TNAME,
   KEY_TUUID,
   KEY_UUID,
   KEY_WS,
   KEY_ZZZ} ;        // rappresenta il numero di elementi

static const std::array<std::string,KEY_ZZZ> sSawingKey = {
   "APPR",
   "CRV",
   "DH",
   "EAL",
   "HS",
   "INV",
   "LETY",
   "LITY",
   "LOTY",
   "NAME",
   "NNS",
   "NNU",
   "PS",
   "SA",
   "SAL",
   "ST",
   "STEA",
   "STIA",
   "STY",
   "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<const SawingData*>( 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_sDepth = pSdata->m_sDepth ;
   m_dStartPos = pSdata->m_dStartPos ;
   m_dStep = pSdata->m_dStep ;
   m_dStepExtArc = pSdata->m_dStepExtArc ;
   m_dStepIntArc = pSdata->m_dStepIntArc ;
   m_nStepType = pSdata->m_nStepType ;
   m_dSideAngle = pSdata->m_dSideAngle ;
   m_dStartAddLen = pSdata->m_dStartAddLen ;
   m_dEndAddLen = pSdata->m_dEndAddLen ;
   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 ;
   m_sSysNotes = pSdata->m_sSysNotes ;
   m_sUserNotes = pSdata->m_sUserNotes ;
   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<const SawingData*>( 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_sDepth == pSdata->m_sDepth  &&
            abs( m_dStartPos - pSdata->m_dStartPos) < EPS_MACH_LEN_PAR  &&
            abs( m_dStep - pSdata->m_dStep) < EPS_MACH_LEN_PAR  &&
            abs( m_dStepExtArc - pSdata->m_dStepExtArc) < EPS_MACH_LEN_PAR  &&
            abs( m_dStepIntArc - pSdata->m_dStepIntArc) < EPS_MACH_LEN_PAR  &&
            m_nStepType == pSdata->m_nStepType  &&
            abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_PAR  &&
            abs( m_dStartAddLen - pSdata->m_dStartAddLen) < EPS_MACH_LEN_PAR  &&
            abs( m_dEndAddLen - pSdata->m_dEndAddLen) < EPS_MACH_LEN_PAR  &&
            m_nLeadInType == pSdata->m_nLeadInType  &&
            m_nExtLinkType == pSdata->m_nExtLinkType  &&
            m_nLeadOutType == pSdata->m_nLeadOutType  &&
            m_nCurveUse == pSdata->m_nCurveUse  &&
            abs( m_dApprox - pSdata->m_dApprox) < EPS_MACH_LEN_PAR  &&
            m_sSysNotes == pSdata->m_sSysNotes  &&
            m_sUserNotes == pSdata->m_sUserNotes) ;
}

//----------------------------------------------------------------------------
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_EAL :
      bOk = ::FromString( sVal, m_dEndAddLen) ;
      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_NNS :
      m_sSysNotes = sVal ;
      break ;
   case KEY_NNU :
      m_sUserNotes = sVal ;
      break ;
   case KEY_PS :
      bOk = ::FromString( sVal, m_dStartPos) ;
      break ;
   case KEY_SA :
      bOk = ::FromString( sVal, m_dSideAngle) ;
      break ;
   case KEY_SAL :
      bOk = ::FromString( sVal, m_dStartAddLen) ;
      break ;
   case KEY_ST :
      bOk = ::FromString( sVal, m_dStep) ;
      break ;
   case KEY_STEA :
      bOk = ::FromString( sVal, m_dStepExtArc) ;
      break ;
   case KEY_STIA :
      bOk = ::FromString( sVal, m_dStepIntArc) ;
      break ;
   case KEY_STY :
      bOk = ::FromString( sVal, m_nStepType) ;
      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_EAL : return ( sSawingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ;
   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_NNS : return ( sSawingKey[KEY_NNS] + "=" + m_sSysNotes) ;
   case KEY_NNU : return ( sSawingKey[KEY_NNU] + "=" + m_sUserNotes) ;
   case KEY_PS : return ( sSawingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
   case KEY_SA : return ( sSawingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
   case KEY_SAL : return ( sSawingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ;
   case KEY_ST : return ( sSawingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
   case KEY_STEA : return ( sSawingKey[KEY_STEA] + "=" + ::ToString( m_dStepExtArc)) ;
   case KEY_STIA : return ( sSawingKey[KEY_STIA] + "=" + ::ToString( m_dStepIntArc)) ;
   case KEY_STY : return ( sSawingKey[KEY_STY] + "=" + ::ToString( m_nStepType)) ;
   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::IsOptional( int nKey) const
{
   return ( nKey == KEY_NNS  ||  nKey == KEY_NNU  ||  nKey == KEY_STEA  ||  nKey == KEY_STIA) ;
}

//----------------------------------------------------------------------------
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::VerifyStepType( int nVal) const
{
   return ( nVal == SAW_ST_ZIGZAG  ||  nVal == SAW_ST_ONEWAY  ||  nVal == SAW_ST_TOANDFROM) ;
}

//----------------------------------------------------------------------------
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 ;
   }
   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_STEPTYPE :
      if ( ! VerifyStepType( nVal))
         return false ;
      m_nStepType = 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_STARTPOS :
      m_dStartPos = dVal ;
      return true ;
   case MPA_STEP :
      m_dStep = dVal ;
      return true ;
   case MPA_STEPEXTARC :
      m_dStepExtArc = dVal ;
      return true ;
   case MPA_STEPINTARC :
      m_dStepIntArc = dVal ;
      return true ;
   case MPA_SIDEANGLE :
      if ( ! VerifySideAngle( dVal))
         return false ;
      m_dSideAngle = dVal ;
      return true ;
   case MPA_STARTADDLEN :
      m_dStartAddLen = dVal ;
      return true ;
   case MPA_ENDADDLEN :
      m_dEndAddLen = 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) ;
   case MPA_SYSNOTES :
      m_sSysNotes = sVal ;
      return true ;
   case MPA_USERNOTES :
      m_sUserNotes = sVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
SawingData::GetParam( int nType, bool& bVal) const
{
   switch ( nType) {
   case MPA_INVERT :
      bVal = m_bInvert ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
SawingData::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case MPA_TYPE :
      nVal = MT_SAWING ;
      return true ;
   case MPA_WORKSIDE :
      nVal = m_nWorkSide ;
      return true ;
   case MPA_HEADSIDE :
      nVal = m_nHeadSide ;
      return true ;
   case MPA_STEPTYPE :
      nVal = m_nStepType ;
      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_STARTPOS :
      dVal = m_dStartPos ;
      return true ;
   case MPA_STEP :
      dVal = m_dStep ;
      return true ;
   case MPA_STEPEXTARC :
      dVal = m_dStepExtArc ;
      return true ;
   case MPA_STEPINTARC :
      dVal = m_dStepIntArc ;
      return true ;
   case MPA_SIDEANGLE :
      dVal = m_dSideAngle ;
      return true ;
   case MPA_STARTADDLEN :
      dVal = m_dStartAddLen ;
      return true ;
   case MPA_ENDADDLEN :
      dVal = m_dEndAddLen ;
      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 ;
   case MPA_SYSNOTES :
      sVal = m_sSysNotes ;
      return true ;
   case MPA_USERNOTES :
      sVal = m_sUserNotes ;
      return true ;
   }
   return false ;
}