EgtMachKernel/WaterJettingData.cpp

//----------------------------------------------------------------------------
//  EgalTech 2019-2019
//----------------------------------------------------------------------------
// File : WaterJettingData.cpp       Data : 08.07.19        Versione : 2.1g2
// Contenuto : Implementazione struttura dati lavorazione di taglio water jet.
//
//
//
// Modifiche : 08.07.19 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "WaterJettingData.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 nWaterJetting {
   KEY_AB = 0,
   KEY_AI,
   KEY_CSL,
   KEY_CSP,
   KEY_EAL,
   KEY_ECT,
   KEY_F,
   KEY_FA,
   KEY_FT,
   KEY_HPT,
   KEY_ICT,
   KEY_INV,
   KEY_LICL,
   KEY_LIH,
   KEY_LIHR,
   KEY_LIPR,
   KEY_LITG,
   KEY_LITY,
   KEY_LOCL,
   KEY_LOPR,
   KEY_LOTG,
   KEY_LOTY,
   KEY_LPT,
   KEY_NAME,
   KEY_NNS,
   KEY_NNU,
   KEY_OR,
   KEY_OVL,
   KEY_PRB,
   KEY_PRBMAX,
   KEY_PRBMIN,
   KEY_S,
   KEY_SA,
   KEY_SAL,
   KEY_SCC,
   KEY_THREF,
   KEY_TNAME,
   KEY_TUUID,
   KEY_UUID,
   KEY_WS,
   KEY_ZZZ} ;        // rappresenta il numero di elementi

static const array<string,KEY_ZZZ> sWaterJettingKey = {
   "AB",
   "AI",
   "CSL",
   "CSP",
   "EAL",
   "ECT",
   "F",
   "FA",
   "FT",
   "HPT",
   "ICT",
   "INV",
   "LICL",
   "LIH",
   "LIHR",
   "LIPR",
   "LITG",
   "LITY",
   "LOCL",
   "LOPR",
   "LOTG",
   "LOTY",
   "LPT",
   "NAME",
   "NNS",
   "NNU",
   "OR",
   "OVL",
   "PRB",
   "PRBMAX",
   "PRBMIN",
   "S",
   "SA",
   "SAL",
   "SCC",
   "THREF",
   "TN",
   "TU",
   "UUID",
   "WS"} ;

//----------------------------------------------------------------------------
MCHDATA_REGISTER( MT_WATERJETTING, "WATERJETTING", WaterJettingData) ;

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

//----------------------------------------------------------------------------
bool
WaterJettingData::CopyFrom( const MachiningData* pMdata)
{
  // è inutile copiare se sorgente coincide con destinazione
   if ( pMdata == this)
      return true ;
  // la sorgente deve essere dello stesso tipo
   const WaterJettingData* pSdata = GetWaterJettingData( 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_sBlockedAxis = pSdata->m_sBlockedAxis ;
   m_sInitAngs = pSdata->m_sInitAngs ;
   m_nSolCh = pSdata->m_nSolCh ;
   m_dSpeed = pSdata->m_dSpeed ;
   m_dFeed = pSdata->m_dFeed ;
   m_dTipFeed = pSdata->m_dTipFeed ;
   m_dThickRef = pSdata->m_dThickRef ;
   m_dOffsR = pSdata->m_dOffsR ;
   m_bInvert = pSdata->m_bInvert ;
   m_nWorkSide = pSdata->m_nWorkSide ;
   m_dOverlap = pSdata->m_dOverlap ;
   m_dSideAngle = pSdata->m_dSideAngle ;
   m_dForwardAngle = pSdata->m_dForwardAngle ;
   m_dStartAddLen = pSdata->m_dStartAddLen ;
   m_dEndAddLen = pSdata->m_dEndAddLen ;
   m_bProbing = pSdata->m_bProbing ;
   m_dProbingMinDist = pSdata->m_dProbingMinDist ;
   m_dProbingMaxDist = pSdata->m_dProbingMaxDist ;
   m_nExtCornerType = pSdata->m_nExtCornerType ;
   m_nIntCornerType = pSdata->m_nIntCornerType ;
   m_dCornerSlowLen = pSdata->m_dCornerSlowLen ;
   m_nCornerSlowPerc = pSdata->m_nCornerSlowPerc ;
   m_nLeadInType = pSdata->m_nLeadInType ;
   m_dLiTang = pSdata->m_dLiTang ;
   m_dLiPerp = pSdata->m_dLiPerp ;
   m_dLiCompLen = pSdata->m_dLiCompLen ;
   m_bLiHole = pSdata->m_bLiHole ;
   m_dLiHoleRad = pSdata->m_dLiHoleRad ;
   m_nLpTurns = pSdata->m_nLpTurns ;
   m_nHpTurns = pSdata->m_nHpTurns ;
   m_nLeadOutType = pSdata->m_nLeadOutType ;
   m_dLoTang = pSdata->m_dLoTang ;
   m_dLoPerp = pSdata->m_dLoPerp ;
   m_dLoCompLen = pSdata->m_dLoCompLen ;
   m_sSysNotes = pSdata->m_sSysNotes ;
   m_sUserNotes = pSdata->m_sUserNotes ;
   return true ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::SameAs( const MachiningData* pMdata) const
{
  // se coincide con altro -> uguali
   if ( pMdata == this)
      return true ;
  // se sono di tipo diverso -> diversi
   const WaterJettingData* pSdata = GetWaterJettingData( 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_sBlockedAxis == pSdata->m_sBlockedAxis  &&
            m_sInitAngs == pSdata->m_sInitAngs  &&
            m_nSolCh == pSdata->m_nSolCh  &&
            abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR  &&
            abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR  &&
            abs( m_dTipFeed - pSdata->m_dTipFeed) < EPS_MACH_LEN_PAR  &&
            abs( m_dThickRef - pSdata->m_dThickRef) < EPS_MACH_LEN_PAR  &&
            abs( m_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR  &&
            m_bInvert == pSdata->m_bInvert  &&
            m_nWorkSide == pSdata->m_nWorkSide  &&
            abs( m_dOverlap - pSdata->m_dOverlap) < EPS_MACH_LEN_PAR  &&
            abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_PAR  &&
            abs( m_dForwardAngle - pSdata->m_dForwardAngle) < 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_bProbing == pSdata->m_bProbing  &&
            abs( m_dProbingMinDist - pSdata->m_dProbingMinDist) < EPS_MACH_LEN_PAR  &&
            abs( m_dProbingMaxDist - pSdata->m_dProbingMaxDist) < EPS_MACH_LEN_PAR  &&
            m_nExtCornerType == pSdata->m_nExtCornerType  &&
            m_nIntCornerType == pSdata->m_nIntCornerType  &&
            abs( m_dCornerSlowLen - pSdata->m_dCornerSlowLen) < EPS_MACH_LEN_PAR  &&
            m_nCornerSlowPerc == pSdata->m_nCornerSlowPerc  &&
            m_nLeadInType == pSdata->m_nLeadInType  &&
            abs( m_dLiTang - pSdata->m_dLiTang) < EPS_MACH_LEN_PAR  &&
            abs( m_dLiPerp - pSdata->m_dLiPerp) < EPS_MACH_LEN_PAR  &&
            abs( m_dLiCompLen - pSdata->m_dLiCompLen) < EPS_MACH_LEN_PAR  &&
            m_bLiHole == pSdata->m_bLiHole  &&
            abs( m_dLiHoleRad - pSdata->m_dLiHoleRad) < EPS_MACH_LEN_PAR  &&
            m_nLpTurns == pSdata->m_nLpTurns  &&
            m_nHpTurns == pSdata->m_nHpTurns  &&
            m_nLeadOutType == pSdata->m_nLeadOutType  &&
            abs( m_dLoTang - pSdata->m_dLoTang) < EPS_MACH_LEN_PAR  &&
            abs( m_dLoPerp - pSdata->m_dLoPerp) < EPS_MACH_LEN_PAR  &&
            abs( m_dLoCompLen - pSdata->m_dLoCompLen) < EPS_MACH_LEN_PAR  &&
            m_sSysNotes == pSdata->m_sSysNotes  &&
            m_sUserNotes == pSdata->m_sUserNotes) ;
}

//----------------------------------------------------------------------------
int
WaterJettingData::GetSize( void) const
{
  // in debug verifico validità ultimo campo
   assert( sWaterJettingKey[KEY_WS] == "WS") ;
   return KEY_ZZZ ;
}
//----------------------------------------------------------------------------
string
WaterJettingData::GetTitle( void) const
{
   return MCHDATA_GETNAME( WaterJettingData) ;
}

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

//----------------------------------------------------------------------------
bool
WaterJettingData::FromString( const string& sString, int& nKey)
{
  // separo chiave da valore
   string sKey, sVal ;
   SplitFirst( sString, "=", sKey, sVal) ;
  // riconosco la chiave
   nKey = FindWaterJettingKey( ToUpper( sKey)) ;
   bool bOk = ( nKey >= 0) ;
   switch ( nKey) {
   case KEY_AB :
      m_sBlockedAxis = sVal ;
      break ;
   case KEY_AI :
      m_sInitAngs = sVal ;
      break ;
   case KEY_CSL :
      bOk = ::FromString( sVal, m_dCornerSlowLen) ;
      break ;
   case KEY_CSP :
      bOk = ::FromString( sVal, m_nCornerSlowPerc) ;
      break ;
   case KEY_EAL :
      bOk = ::FromString( sVal, m_dEndAddLen) ;
      break ;
   case KEY_ECT :
      bOk = ::FromString( sVal, m_nExtCornerType) ;
      break ;
   case KEY_F :
      bOk = ::FromString( sVal, m_dFeed) ;
      break ;
   case KEY_FA :
      bOk = ::FromString( sVal, m_dForwardAngle) ;
      break ;
   case KEY_FT :
      bOk = ::FromString( sVal, m_dTipFeed) ;
      break ;
   case KEY_HPT :
      bOk = ::FromString( sVal, m_nHpTurns) ;
      break ;
   case KEY_ICT :
      bOk = ::FromString( sVal, m_nIntCornerType) ;
      break ;
   case KEY_INV :
      bOk = ::FromString( sVal, m_bInvert) ;
      break ;
   case KEY_LICL :
      bOk = ::FromString( sVal, m_dLiCompLen) ;
      break ;
   case KEY_LIH :
      bOk = ::FromString( sVal, m_bLiHole) ;
      break ;
   case KEY_LIHR :
      bOk = ::FromString( sVal, m_dLiHoleRad) ;
      break ;
   case KEY_LIPR :
      bOk = ::FromString( sVal, m_dLiPerp) ;
      break ;
   case KEY_LITG :
      bOk = ::FromString( sVal, m_dLiTang) ;
      break ;
   case KEY_LITY :
      bOk = ::FromString( sVal, m_nLeadInType) ;
      break ;
   case KEY_LOCL :
      bOk = ::FromString( sVal, m_dLoCompLen) ;
      break ;
   case KEY_LOPR :
      bOk = ::FromString( sVal, m_dLoPerp) ;
      break ;
   case KEY_LOTG :
      bOk = ::FromString( sVal, m_dLoTang) ;
      break ;
   case KEY_LOTY :
      bOk = ::FromString( sVal, m_nLeadOutType) ;
      break ;
   case KEY_LPT :
      bOk = ::FromString( sVal, m_nLpTurns) ;
      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_OR :
      bOk = ::FromString( sVal, m_dOffsR) ;
      break ;
   case KEY_PRB :
      bOk = ::FromString( sVal, m_bProbing) ;
      break ;
   case KEY_PRBMAX :
      bOk = ::FromString( sVal, m_dProbingMaxDist) ;
      break ;
   case KEY_PRBMIN :
      bOk = ::FromString( sVal, m_dProbingMinDist) ;
      break ;
   case KEY_OVL :
      bOk = ::FromString( sVal, m_dOverlap) ;
      break ;
   case KEY_S :
      bOk = ::FromString( sVal, m_dSpeed) ;
      break ;
   case KEY_SA :
      bOk = ::FromString( sVal, m_dSideAngle) ;
      break ;
   case KEY_SAL :
      bOk = ::FromString( sVal, m_dStartAddLen) ;
      break ;
   case KEY_SCC :
      bOk = ::FromString( sVal, m_nSolCh) ;
      break ;
   case KEY_THREF :
      bOk = ::FromString( sVal, m_dThickRef) ;
      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
WaterJettingData::ToString( int nInd) const
{
   switch ( nInd) {
   case KEY_AB : return ( sWaterJettingKey[KEY_AB] + "=" +  m_sBlockedAxis) ;
   case KEY_AI : return ( sWaterJettingKey[KEY_AI] + "=" +  m_sInitAngs) ;
   case KEY_CSL : return ( sWaterJettingKey[KEY_CSL] + "=" + ::ToString( m_dCornerSlowLen)) ;
   case KEY_CSP : return ( sWaterJettingKey[KEY_CSP] + "=" + ::ToString( m_nCornerSlowPerc)) ;
   case KEY_EAL : return ( sWaterJettingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ;
   case KEY_ECT : return ( sWaterJettingKey[KEY_ECT] + "=" + ::ToString( m_nExtCornerType)) ;
   case KEY_F : return ( sWaterJettingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
   case KEY_FA : return ( sWaterJettingKey[KEY_FA] + "=" + ::ToString( m_dForwardAngle)) ;
   case KEY_FT : return ( sWaterJettingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
   case KEY_HPT : return ( sWaterJettingKey[KEY_HPT] + "=" + ::ToString( m_nHpTurns)) ;
   case KEY_ICT : return ( sWaterJettingKey[KEY_ICT] + "=" + ::ToString( m_nIntCornerType)) ;
   case KEY_INV : return ( sWaterJettingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
   case KEY_LICL : return ( sWaterJettingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ;
   case KEY_LIH : return ( sWaterJettingKey[KEY_LIH] + "=" + ::ToString( m_bLiHole)) ;
   case KEY_LIHR : return ( sWaterJettingKey[KEY_LIHR] + "=" + ::ToString( m_dLiHoleRad)) ;
   case KEY_LIPR : return ( sWaterJettingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ;
   case KEY_LITG : return ( sWaterJettingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ;
   case KEY_LITY : return ( sWaterJettingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ;
   case KEY_LOCL : return ( sWaterJettingKey[KEY_LOCL] + "=" + ::ToString( m_dLoCompLen)) ;
   case KEY_LOPR : return ( sWaterJettingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ;
   case KEY_LOTG : return ( sWaterJettingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ;
   case KEY_LOTY : return ( sWaterJettingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ;
   case KEY_LPT : return ( sWaterJettingKey[KEY_LPT] + "=" + ::ToString( m_nLpTurns)) ;
   case KEY_NAME : return ( sWaterJettingKey[KEY_NAME] + "=" + m_sName) ;
   case KEY_NNS : return ( sWaterJettingKey[KEY_NNS] + "=" + m_sSysNotes) ;
   case KEY_NNU : return ( sWaterJettingKey[KEY_NNU] + "=" + m_sUserNotes) ;
   case KEY_OR : return ( sWaterJettingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ;
   case KEY_OVL : return ( sWaterJettingKey[KEY_OVL] + "=" + ::ToString( m_dOverlap)) ;
   case KEY_PRB : return ( sWaterJettingKey[KEY_PRB] + "=" + ::ToString( m_bProbing)) ;
   case KEY_PRBMAX : return ( sWaterJettingKey[KEY_PRBMAX] + "=" + ::ToString( m_dProbingMaxDist)) ;
   case KEY_PRBMIN : return ( sWaterJettingKey[KEY_PRBMIN] + "=" + ::ToString( m_dProbingMinDist)) ;
   case KEY_S : return ( sWaterJettingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ;
   case KEY_SA : return ( sWaterJettingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
   case KEY_SAL : return ( sWaterJettingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ;
   case KEY_SCC : return ( sWaterJettingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
   case KEY_THREF : return ( sWaterJettingKey[KEY_THREF] + "=" + ::ToString( m_dThickRef)) ;
   case KEY_TNAME : return ( sWaterJettingKey[KEY_TNAME] + "=" + m_sToolName) ;
   case KEY_TUUID : return ( sWaterJettingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
   case KEY_UUID : return ( sWaterJettingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
   case KEY_WS : return ( sWaterJettingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ;
   default : return "" ;
   }
}

//----------------------------------------------------------------------------
bool
WaterJettingData::IsOptional( int nKey) const
{
   return ( nKey == KEY_FA  ||  nKey == KEY_PRB  ||  nKey == KEY_PRBMAX  ||  nKey == KEY_PRBMIN  ||
            nKey == KEY_ECT  ||  nKey == KEY_ICT  ||  nKey ==  KEY_CSL  ||  nKey ==  KEY_CSP  ||
            nKey == KEY_LIH  ||  nKey == KEY_LIHR  ||  nKey == KEY_LPT  ||  nKey == KEY_HPT  ||
            nKey == KEY_THREF) ;
}

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

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyWorkSide( int nVal) const
{
   return ( nVal == WJET_WS_CENTER  ||  nVal == WJET_WS_LEFT  ||  nVal == WJET_WS_RIGHT) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyExtCornerType( int nVal) const
{
   return ( nVal == WJET_EC_NONE  ||  nVal == WJET_EC_SLOW  ||  nVal == WJET_EC_LOOP) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyIntCornerType( int nVal) const
{
   return ( nVal == WJET_IC_NONE  ||  nVal == WJET_IC_SLOW  ||  nVal == WJET_IC_SLOW_FULL) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyCornerSlowPerc( int nVal) const
{
   return ( nVal >= 0  &&  nVal <= 100) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyLeadInType( int nVal) const
{
   return ( nVal == WJET_LI_NONE  ||  nVal == WJET_LI_LINEAR  ||  nVal == WJET_LI_TANGENT) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyLeadOutType( int nVal) const
{
   return ( nVal == WJET_LO_NONE  ||  nVal == WJET_LO_LINEAR  ||
            nVal == WJET_LO_TANGENT  ||  nVal == WJET_LO_AS_LI) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifySideAngle( double dVal) const
{
   const double MAX_SIDE_ANG = 60.0 + EPS_ANG_SMALL ;
   const double AUTO_SIDE_ANG = 99 ;
   return ( ( dVal > - MAX_SIDE_ANG  &&  dVal < MAX_SIDE_ANG)  ||  abs( dVal - AUTO_SIDE_ANG) < EPS_ANG_SMALL) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyForwardAngle( double dVal) const
{
   const double MAX_FORW_ANG = 30.0 + EPS_ANG_SMALL ;
   const double AUTO_FORW_ANG = 99 ;
   return ( ( dVal > - EPS_ZERO  &&  dVal < MAX_FORW_ANG)  ||  abs( dVal - AUTO_FORW_ANG) < EPS_ANG_SMALL) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::VerifyThickRef( double dVal) const
{
   const double MIN_THICKREF = 1 ;
   return ( abs( dVal) < EPS_SMALL  ||  dVal >= MIN_THICKREF) ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::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 & TF_WATERJET) == 0)
      return false ;
   return true ;
}

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

//----------------------------------------------------------------------------
bool
WaterJettingData::SetParam( int nType, bool bVal)
{
   switch ( nType) {
   case MPA_INVERT :
      m_bInvert = bVal ;
      return true ;
   case MPA_PROBING :
      m_bProbing = bVal ;
      return true ;
   case MPA_LIHOLE :
      m_bLiHole = bVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::SetParam( int nType, int nVal)
{
   switch ( nType) {
   case MPA_WORKSIDE :
      if ( ! VerifyWorkSide( nVal))
         return false ;
      m_nWorkSide = nVal ;
      return true ;
   case MPA_EXTCORNERTYPE :
      if ( ! VerifyExtCornerType( nVal))
         return false ;
      m_nExtCornerType = nVal ;
      break ;
   case MPA_INTCORNERTYPE :
      if ( ! VerifyIntCornerType( nVal))
         return false ;
      m_nIntCornerType = nVal ;
      break ;
   case MPA_CORNERSLOWPERC :
      if ( ! VerifyCornerSlowPerc( nVal))
         return false ;
      m_nCornerSlowPerc = nVal ;
      break ;
   case MPA_LEADINTYPE :
      if ( ! VerifyLeadInType( nVal))
         return false ;
      m_nLeadInType = nVal ;
      return true ;
   case MPA_LEADOUTTYPE :
      if ( ! VerifyLeadOutType( nVal))
         return false ;
      m_nLeadOutType = nVal ;
      return true ;
   case MPA_LPTURNS :
      m_nLpTurns = nVal ;
      break ;
   case MPA_HPTURNS :
      m_nHpTurns = nVal ;
      break ;
   case MPA_SCC :
      if ( ! VerifySolCh( nVal))
         return false ;
      m_nSolCh = nVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::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_TIPFEED :
      m_dTipFeed = dVal ;
      return true ;
   case MPA_THICKREF :
      if ( ! VerifyThickRef( dVal))
         return false ;
      m_dThickRef = dVal ;
      return true ;
   case MPA_OFFSR :
      m_dOffsR = dVal ;
      return true ;
   case MPA_OVERL :
      m_dOverlap = dVal ;
      return true ;
   case MPA_SIDEANGLE :
      if ( ! VerifySideAngle( dVal))
         return false ;
      m_dSideAngle = dVal ;
      return true ;
   case MPA_FORWARDANGLE :
      if ( ! VerifyForwardAngle( dVal))
         return false ;
      m_dForwardAngle = dVal ;
      return true ;
   case MPA_STARTADDLEN :
      m_dStartAddLen = dVal ;
      return true ;
   case MPA_ENDADDLEN :
      m_dEndAddLen = dVal ;
      return true ;
   case MPA_PROBINGMINDIST :
      m_dProbingMinDist = dVal ;
      return true ;
   case MPA_PROBINGMAXDIST :
      m_dProbingMaxDist = dVal ;
      return true ;
   case MPA_CORNERSLOWLEN :
      m_dCornerSlowLen = dVal ;
      return true ;
   case MPA_LITANG :
      m_dLiTang = dVal ;
      return true ;
   case MPA_LIPERP :
      m_dLiPerp = dVal ;
      return true ;
   case MPA_LICOMPLEN :
      m_dLiCompLen = dVal ;
      return true ;
   case MPA_LIHOLERAD :
      m_dLiHoleRad = dVal ;
      return true ;
   case MPA_LOTANG :
      m_dLoTang = dVal ;
      return true ;
   case MPA_LOPERP :
      m_dLoPerp = dVal ;
      return true ;
   case MPA_LOCOMPLEN :
      m_dLoCompLen = dVal ;
      return true ;
   }
   return false ;
}

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

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

//----------------------------------------------------------------------------
bool
WaterJettingData::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case MPA_TYPE :
      nVal = MT_WATERJETTING ;
      return true ;
   case MPA_WORKSIDE :
      nVal = m_nWorkSide ;
      return true ;
   case MPA_EXTCORNERTYPE :
      nVal = m_nExtCornerType ;
      return true ;
   case MPA_INTCORNERTYPE :
      nVal = m_nIntCornerType ;
      return true ;
   case MPA_CORNERSLOWPERC :
      nVal = m_nCornerSlowPerc ;
      return true ;
   case MPA_LEADINTYPE :
      nVal = m_nLeadInType ;
      return true ;
   case MPA_LEADOUTTYPE :
      nVal = m_nLeadOutType ;
      return true ;
   case MPA_LPTURNS :
      nVal = m_nLpTurns ;
      return true ;
   case MPA_HPTURNS :
      nVal = m_nHpTurns ;
      return true ;
   case MPA_SCC :
      nVal = m_nSolCh ;
      return true ;
   }
   nVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
WaterJettingData::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_TIPFEED :
      dVal = m_dTipFeed ;
      return true ;
   case MPA_THICKREF :
      dVal = m_dThickRef ;
      return true ;
   case MPA_OFFSR :
      dVal = m_dOffsR ;
      return true ;
   case MPA_OVERL :
      dVal = m_dOverlap ;
      return true ;
   case MPA_SIDEANGLE :
      dVal = m_dSideAngle ;
      return true ;
   case MPA_FORWARDANGLE :
      dVal = m_dForwardAngle ;
      return true ;
   case MPA_STARTADDLEN :
      dVal = m_dStartAddLen ;
      return true ;
   case MPA_ENDADDLEN :
      dVal = m_dEndAddLen ;
      return true ;
   case MPA_PROBINGMINDIST :
      dVal = m_dProbingMinDist ;
      return true ;
   case MPA_PROBINGMAXDIST :
      dVal = m_dProbingMaxDist ;
      return true ;
   case MPA_CORNERSLOWLEN :
      dVal = m_dCornerSlowLen ;
      return true ;
   case MPA_LITANG :
      dVal = m_dLiTang ;
      return true ;
   case MPA_LIPERP :
      dVal = m_dLiPerp ;
      return true ;
   case MPA_LICOMPLEN :
      dVal = m_dLiCompLen ;
      return true ;
   case MPA_LIHOLERAD :
      dVal = m_dLiHoleRad ;
      return true ;
   case MPA_LOTANG :
      dVal = m_dLoTang ;
      return true ;
   case MPA_LOPERP :
      dVal = m_dLoPerp ;
      return true ;
   case MPA_LOCOMPLEN :
      dVal = m_dLoCompLen ;
      return true ;
   }
   dVal = 0 ;
   return false ;
}

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