EgtMachKernel/MortisingData.cpp

//----------------------------------------------------------------------------
//  EgalTech 2018-2018
//----------------------------------------------------------------------------
// File : MortisingData.cpp       Data : 25.02.18        Versione : 1.9cb1
// Contenuto : Implementazione struttura dati lavorazione di mortasatura.
//
//
//
// Modifiche : 25.02.18 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MortisingData.h"
#include "MachiningDataFactory.h"
#include "MachiningConst.h"
#include "/EgtDev/Include/EmkToolConst.h"
#include "/EgtDev/Include/EmkSimuGenConst.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include <array>
#include <cassert>

using namespace std ;

//----------------------------------------------------------------------------
enum nMortisingKey {
   KEY_AB = 0,
   KEY_AI,
   KEY_DH,
   KEY_EAL,
   KEY_F,
   KEY_FE,
   KEY_FS,
   KEY_FT,
   KEY_FU,
   KEY_INV,
   KEY_NAME,
   KEY_NNS,
   KEY_NNU,
   KEY_OL,
   KEY_OR,
   KEY_PS,
   KEY_S,
   KEY_SAL,
   KEY_SCC,
   KEY_ST,
   KEY_STY,
   KEY_TI,
   KEY_TNAME,
   KEY_TUUID,
   KEY_UUID,
   KEY_WS,
   KEY_ZZZ} ;        // rappresenta il numero di elementi

static const array<string,KEY_ZZZ> sMortisingKey = {
   "AB",
   "AI",
   "DH",
   "EAL",
   "F",
   "FE",
   "FS",
   "FT",
   "FU",
   "INV",
   "NAME",
   "NNS",
   "NNU",
   "OL",
   "OR",
   "PS",
   "S",
   "SAL",
   "SCC",
   "ST",
   "STY",
   "TI",
   "TN",
   "TU",
   "UUID",
   "WS"} ;

//----------------------------------------------------------------------------
MCHDATA_REGISTER( MT_MORTISING, "MORTISING", MortisingData) ;

//----------------------------------------------------------------------------
MortisingData*
MortisingData::Clone( void) const
{
  // alloco oggetto
   MortisingData* pDdata = new(nothrow) MortisingData ;
  // copio i dati
   if ( pDdata != nullptr) {
      if ( ! pDdata->CopyFrom( this)) {
         delete pDdata ;
         return nullptr ;
      }
   }
   return pDdata ;
}

//----------------------------------------------------------------------------
bool
MortisingData::CopyFrom( const MachiningData* pMdata)
{
  // è inutile copiare se sorgente coincide con destinazione
   if ( pMdata == this)
      return true ;
  // la sorgente deve essere dello stesso tipo
   const MortisingData* pDdata = GetMortisingData( 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_dSpeed = pDdata->m_dSpeed ;
   m_dFeed = pDdata->m_dFeed ;
   m_dStartFeed = pDdata->m_dStartFeed ;
   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_nFaceUse = pDdata->m_nFaceUse ;
   m_bInvert = pDdata->m_bInvert ;
   m_sDepth = pDdata->m_sDepth ;
   m_dStartPos = pDdata->m_dStartPos ;
   m_dStep = pDdata->m_dStep ;
   m_nStepType = pDdata->m_nStepType ;
   m_dStartAddLen = pDdata->m_dStartAddLen ;
   m_dEndAddLen = pDdata->m_dEndAddLen ;
   m_sSysNotes = pDdata->m_sSysNotes ;
   m_sUserNotes = pDdata->m_sUserNotes ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MortisingData::SameAs(const MachiningData* pMdata) const
{
  // se coincide con altro -> uguali
   if ( pMdata == this)
      return true ;
  // se sono di tipo diverso -> diversi
   const MortisingData* pDdata = GetMortisingData( 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_dSpeed - pDdata->m_dSpeed) < EPS_MACH_ANG_PAR  &&
            abs( m_dFeed - pDdata->m_dFeed) < EPS_MACH_LEN_PAR  &&
            abs( m_dStartFeed - pDdata->m_dStartFeed) < 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_nFaceUse == pDdata->m_nFaceUse  &&
            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  &&
            m_nStepType == pDdata->m_nStepType  &&
            abs( m_dStartAddLen - pDdata->m_dStartAddLen) < 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
MortisingData::GetSize( void) const
{
  // in debug verifico validità ultimo campo
   assert( sMortisingKey[KEY_WS] == "WS") ;
   return KEY_ZZZ ;
}
//----------------------------------------------------------------------------
string
MortisingData::GetTitle( void) const
{
   return MCHDATA_GETNAME( MortisingData) ;
}

//----------------------------------------------------------------------------
int
FindMortisingKey( const string& sKey)
{
   auto TheRange = equal_range( sMortisingKey.cbegin(), sMortisingKey.cend(), sKey) ;
   if ( TheRange.first == TheRange.second)
      return - 1 ;
   return int( TheRange.first - sMortisingKey.cbegin()) ;
}

//----------------------------------------------------------------------------
bool
MortisingData::FromString( const string& sString, int& nKey)
{
  // separo chiave da valore
   string sKey, sVal ;
   SplitFirst( sString, "=", sKey, sVal) ;
  // riconosco la chiave
   nKey = FindMortisingKey( 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_FS :
      bOk = ::FromString( sVal, m_dStartFeed) ;
      break ;
   case KEY_FT :
      bOk = ::FromString( sVal, m_dTipFeed) ;
      break ;
   case KEY_FU :
      bOk = ::FromString( sVal, m_nFaceUse) ;
      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_PS :
      bOk = ::FromString( sVal, m_dStartPos) ;
      break ;
   case KEY_S :
      bOk = ::FromString( sVal, m_dSpeed) ;
      break ;
   case KEY_SAL :
      bOk = ::FromString( sVal, m_dStartAddLen) ;
      break ;
   case KEY_SCC :
      bOk = ::FromString( sVal, m_nSolCh) ;
      break ;
   case KEY_ST :
      bOk = ::FromString( sVal, m_dStep) ;
      break ;
   case KEY_STY :
      bOk = ::FromString( sVal, m_nStepType) ;
      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
MortisingData::ToString( int nKey) const
{
   switch ( nKey) {
   case KEY_AB : return ( sMortisingKey[KEY_AB] + "=" +  m_sBlockedAxis) ;
   case KEY_AI : return ( sMortisingKey[KEY_AI] + "=" +  m_sInitAngs) ;
   case KEY_DH : return ( sMortisingKey[KEY_DH] + "=" + m_sDepth) ;
   case KEY_EAL : return ( sMortisingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ;
   case KEY_F : return ( sMortisingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
   case KEY_FE : return ( sMortisingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
   case KEY_FS : return ( sMortisingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ;
   case KEY_FT : return ( sMortisingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
   case KEY_FU : return ( sMortisingKey[KEY_FU] + "=" + ::ToString( m_nFaceUse)) ;
   case KEY_INV : return ( sMortisingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
   case KEY_NAME : return ( sMortisingKey[KEY_NAME] + "=" + m_sName) ;
   case KEY_NNS : return ( sMortisingKey[KEY_NNS] + "=" + m_sSysNotes) ;
   case KEY_NNU : return ( sMortisingKey[KEY_NNU] + "=" + m_sUserNotes) ;
   case KEY_OL : return ( sMortisingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ;
   case KEY_OR : return ( sMortisingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ;
   case KEY_PS : return ( sMortisingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
   case KEY_S : return ( sMortisingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ;
   case KEY_SAL : return ( sMortisingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ;
   case KEY_SCC : return ( sMortisingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
   case KEY_ST : return ( sMortisingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
   case KEY_STY : return ( sMortisingKey[KEY_STY] + "=" + ::ToString( m_nStepType)) ;
   case KEY_TI : return ( sMortisingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ;
   case KEY_TNAME : return ( sMortisingKey[KEY_TNAME] + "=" + m_sToolName) ;
   case KEY_TUUID : return ( sMortisingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
   case KEY_UUID : return ( sMortisingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
   case KEY_WS : return ( sMortisingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ;
   default : return "" ;
   }
}

//----------------------------------------------------------------------------
bool
MortisingData::IsOptional( int nKey) const
{
   return ( nKey == KEY_ST  ||  nKey == KEY_STY) ;
}

//----------------------------------------------------------------------------
bool
MortisingData::VerifySolCh( int nVal) const
{
   return IsValidOperationScc( nVal) ;
}

//----------------------------------------------------------------------------
bool
MortisingData::VerifyFaceUse( int nVal) const
{
   return ( nVal == MORTISE_FU_NONE  ||
            ( nVal >= MORTISE_FU_PARAL_DOWN  &&  nVal <= MORTISE_FU_PARAL_RIGHT)) ;
}

//----------------------------------------------------------------------------
bool
MortisingData::VerifyWorkSide( int nVal) const
{
   return ( nVal == MORTISE_WS_LEFT  ||  nVal == MORTISE_WS_RIGHT) ;
}

//----------------------------------------------------------------------------
bool
MortisingData::VerifyStepType( int nVal) const
{
   return ( nVal == MORTISE_ST_ZIGZAG  ||  nVal == MORTISE_ST_ONEWAY) ;
}

//----------------------------------------------------------------------------
bool
MortisingData::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_MORTISE_STD)
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MortisingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const
{
   if ( pToolsMgr == nullptr)
      return false ;
   pTdata = pToolsMgr->GetTool( m_ToolUuid) ;
   return ( pTdata != nullptr) ;
}

//----------------------------------------------------------------------------
bool
MortisingData::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
MortisingData::SetParam( int nType, int nVal)
{
   switch ( nType) {
   case MPA_WORKSIDE :
      if ( ! VerifyWorkSide( nVal))
         return false ;
      m_nWorkSide = nVal ;
      return true ;
   case MPA_STEPTYPE :
      if ( ! VerifyStepType( nVal))
         return false ;
      m_nStepType = nVal ;
      return true ;
   case MPA_SCC :
      if ( ! VerifySolCh( nVal))
         return false ;
      m_nSolCh = nVal ;
      return true ;
   case MPA_FACEUSE :
      if ( ! VerifyFaceUse( nVal))
         return false ;
      m_nFaceUse = nVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MortisingData::SetParam( int nType, double dVal)
{
   switch ( nType) {
   case MPA_SPEED :
      m_dSpeed = dVal ;
      return true ;
   case MPA_FEED :
      m_dFeed = dVal ;
      return true ;
   case MPA_STARTFEED :
      m_dStartFeed = 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_STARTADDLEN :
      m_dStartAddLen = dVal ;
      return true ;
   case MPA_ENDADDLEN :
      m_dEndAddLen = dVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MortisingData::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
MortisingData::ResetTool( void)
{
   m_sToolName.clear() ;
   m_ToolUuid.Clear() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MortisingData::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
MortisingData::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case MPA_TYPE :
      nVal = MT_MORTISING ;
      return true ;
   case MPA_WORKSIDE :
      nVal = m_nWorkSide ;
      return true ;
   case MPA_STEPTYPE :
      nVal = m_nStepType ;
      return true ;
   case MPA_SCC :
      nVal = m_nSolCh ;
      return true ;
   case MPA_FACEUSE :
      nVal = m_nFaceUse ;
      return true ;
   }
   nVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
MortisingData::GetParam( int nType, double& dVal) const
{
   switch ( nType) {
   case MPA_SPEED :
      dVal = m_dSpeed ;
      return true ;
   case MPA_FEED :
      dVal = m_dFeed ;
      return true ;
   case MPA_STARTFEED :
      dVal = m_dStartFeed ;
      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_STARTADDLEN :
      dVal = m_dStartAddLen ;
      return true ;
   case MPA_ENDADDLEN :
      dVal = m_dEndAddLen ;
      return true ;
   }
   dVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
MortisingData::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 ;
}