EgtMachKernel/DrillingData.cpp

//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : DrillingData.cpp       Data : 04.06.15          Versione : 1.6f1
// Contenuto : Implementazione struttura dati lavorazione di foratura.
//
//
//
// Modifiche : 04.06.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

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

using namespace std ;

//----------------------------------------------------------------------------
enum nDrillingKey {
   KEY_INV = 0,
   KEY_LAT,
   KEY_LSE,
   KEY_LSS,
   KEY_NAME,
   KEY_PR,
   KEY_PS,
   KEY_ST,
   KEY_TNAME,
   KEY_TUUID,
   KEY_UUID,
   KEY_ZZZ} ;        // rappresenta il numero di elementi

static const std::array<std::string,KEY_ZZZ> sDrillingKey = {
   "INV",
   "LAT",
   "LSE",
   "LSS",
   "NAME",
   "PR",
   "PS",
   "ST",
   "TN",
   "TU",
   "UUID"} ;

//----------------------------------------------------------------------------
MCHDATA_REGISTER( MT_DRILLING, "DRILLING", DrillingData) ;

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

//----------------------------------------------------------------------------
bool
DrillingData::CopyFrom( const MachiningData* pMdata)
{
  // è inutile copiare se sorgente coincide con destinazione
   if ( pMdata == this)
      return true ;
  // la sorgente deve essere dello stesso tipo
   const DrillingData* pDdata = dynamic_cast<const DrillingData*>( 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_bInvert = pDdata->m_bInvert ;
   m_dStartPos = pDdata->m_dStartPos ;
   m_dStartSlowLen = pDdata->m_dStartSlowLen ;
   m_dEndSlowLen = pDdata->m_dEndSlowLen ;
   m_dThroughAddLen = pDdata->m_dThroughAddLen ;
   m_dStep = pDdata->m_dStep ;
   m_dReturnPos = pDdata->m_dReturnPos ;
   return true ;
}

//----------------------------------------------------------------------------
bool
DrillingData::SameAs(const MachiningData* pMdata) const
{
  // se coincide con altro -> uguali
   if ( pMdata == this)
      return true ;
  // se sono di tipo diverso -> diversi
   const DrillingData* pDdata = dynamic_cast<const DrillingData*>( 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_bInvert == pDdata->m_bInvert  &&
            m_dStartPos == pDdata->m_dStartPos  &&
            m_dStartSlowLen == pDdata->m_dStartSlowLen  &&
            m_dEndSlowLen == pDdata->m_dEndSlowLen  &&
            m_dThroughAddLen == pDdata->m_dThroughAddLen  &&
            m_dStep == pDdata->m_dStep  &&
            m_dReturnPos == pDdata->m_dReturnPos) ;
}

//----------------------------------------------------------------------------
int
DrillingData::GetSize( void) const
{
  // in debug verifico validità ultimo campo
   assert( sDrillingKey[KEY_UUID] == "UUID") ;
   return KEY_ZZZ ;
}
//----------------------------------------------------------------------------
string
DrillingData::GetTitle( void) const
{
   return MCHDATA_GETNAME( DrillingData) ;
}

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

//----------------------------------------------------------------------------
bool
DrillingData::FromString( const string& sString, int& nKey)
{
  // separo chiave da valore
   string sKey, sVal ;
   SplitFirst( sString, "=", sKey, sVal) ;
  // riconosco la chiave
   nKey = FindDrillingKey( ToUpper( sKey)) ;
   bool bOk = ( nKey >= 0) ;
   switch ( nKey) {
   case KEY_INV :
      bOk = ::FromString( sVal, m_bInvert) ;
      break ;
   case KEY_LAT :
      bOk = ::FromString( sVal, m_dThroughAddLen) ;
      break ;
   case KEY_LSE :
      bOk = ::FromString( sVal, m_dEndSlowLen) ;
      break ;
   case KEY_LSS :
      bOk = ::FromString( sVal, m_dStartSlowLen) ;
      break ;
   case KEY_NAME :
      m_sName = sVal ;
      bOk = ! m_sName.empty() ;
      break ;
   case KEY_PR :
      bOk = ::FromString( sVal, m_dReturnPos) ;
      break ;
   case KEY_PS :
      bOk = ::FromString( sVal, m_dStartPos) ;
      break ;
   case KEY_ST :
      bOk = ::FromString( sVal, m_dStep) ;
      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 ;
   default :
      bOk = false ;
      break ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
string
DrillingData::ToString( int nInd) const
{
   switch ( nInd) {
   case KEY_INV : return ( sDrillingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
   case KEY_LAT : return ( sDrillingKey[KEY_LAT] + "=" + ::ToString( m_dThroughAddLen)) ;
   case KEY_LSE : return ( sDrillingKey[KEY_LSE] + "=" + ::ToString( m_dEndSlowLen)) ;
   case KEY_LSS : return ( sDrillingKey[KEY_LSS] + "=" + ::ToString( m_dStartSlowLen)) ;
   case KEY_NAME : return ( sDrillingKey[KEY_NAME] + "=" + m_sName) ;
   case KEY_PR : return ( sDrillingKey[KEY_PR] + "=" + ::ToString( m_dReturnPos)) ;
   case KEY_PS : return ( sDrillingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
   case KEY_ST : return ( sDrillingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
   case KEY_TNAME : return ( sDrillingKey[KEY_TNAME] + "=" + m_sToolName) ;
   case KEY_TUUID : return ( sDrillingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
   case KEY_UUID : return ( sDrillingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
   default : return "" ;
   }
}

//----------------------------------------------------------------------------
bool
DrillingData::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_DRILLBIT) == 0  ||
        pTdata->m_nType != TT_MILL_STD)
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
DrillingData::SetParam( int nType, bool bVal)
{
   switch ( nType) {
   case MPA_INVERT :
      m_bInvert = bVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
DrillingData::SetParam( int nType, int nVal)
{
   return false ;
}

//----------------------------------------------------------------------------
bool
DrillingData::SetParam( int nType, double dVal)
{
   switch ( nType) {
   case MPA_STARTPOS :
      m_dStartPos = dVal ;
      return true ;
   case MPA_STARTSLOWLEN :
      m_dStartSlowLen = dVal ;
      return true ;
   case MPA_ENDSLOWLEN :
      m_dEndSlowLen = dVal ;
      return true ;
   case MPA_THROUADDLEN :
      m_dThroughAddLen = dVal ;
      return true ;
   case MPA_STEP :
      m_dStep = dVal ;
      return true ;
   case MPA_RETURNPOS :
      m_dReturnPos = dVal ;
      return true ;
   }
   return false ;
}

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

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

//----------------------------------------------------------------------------
bool
DrillingData::GetParam( int nType, int& nVal) const
{
   return false ;
}

//----------------------------------------------------------------------------
bool
DrillingData::GetParam( int nType, double& dVal) const
{
   switch ( nType) {
   case MPA_STARTPOS :
      dVal = m_dStartPos ;
      return true ;
   case MPA_STARTSLOWLEN :
      dVal = m_dStartSlowLen ;
      return true ;
   case MPA_ENDSLOWLEN :
      dVal = m_dEndSlowLen ;
      return true ;
   case MPA_THROUADDLEN :
      dVal = m_dThroughAddLen ;
      return true ;
   case MPA_STEP :
      dVal = m_dStep ;
      return true ;
   case MPA_RETURNPOS :
      dVal = m_dReturnPos ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
DrillingData::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 ;
   }
   return false ;
}