EgtMachKernel/MillingData.cpp

//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : MillingData.cpp       Data : 05.06.15          Versione : 1.6f1
// Contenuto : Implementazione struttura dati lavorazione di fresatura.
//
//
//
// Modifiche : 05.06.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

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

using namespace std ;

//----------------------------------------------------------------------------
enum nMillingKey {
   KEY_DH = 0,
   KEY_INV,
   KEY_LICL,
   KEY_LIEL,
   KEY_LIPR,
   KEY_LITG,
   KEY_LITY,
   KEY_LOCL,
   KEY_LOEL,
   KEY_LOPR,
   KEY_LOTG,
   KEY_LOTY,
   KEY_LT,
   KEY_NAME,
   KEY_OL,
   KEY_OM,
   KEY_SA,
   KEY_ST,
   KEY_STY,
   KEY_TA,
   KEY_TD,
   KEY_TH,
   KEY_TL,
   KEY_TNAME,
   KEY_TUUID,
   KEY_UUID,
   KEY_WS,
   KEY_ZZZ} ;        // rappresenta il numero di elementi

static const std::array<std::string,KEY_ZZZ> sMillingKey = {
   "DH",
   "INV",
   "LICL",
   "LIEL",
   "LIPR",
   "LITG",
   "LITY",
   "LOCL",
   "LOEL",
   "LOPR",
   "LOTG",
   "LOTY",
   "LT",
   "NAME",
   "OL",
   "OM",
   "SA",
   "ST",
   "STY",
   "TA",
   "TD",
   "TH",
   "TL",
   "TN",
   "TU",
   "UUID",
   "WS"} ;

//----------------------------------------------------------------------------
MCHDATA_REGISTER( "MILLING", MillingData) ;

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

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

//----------------------------------------------------------------------------
bool
MillingData::FromString( const string& sString, int& nKey)
{
  // separo chiave da valore
   string sKey, sVal ;
   SplitFirst( sString, "=", sKey, sVal) ;
  // riconosco la chiave
   nKey = FindMillingKey( ToUpper( sKey)) ;
   bool bOk = ( nKey >= 0) ;
   switch ( nKey) {
   case KEY_DH :
      bOk = ::FromString( sVal, m_dDepth) ;
      break ;
   case KEY_INV :
      bOk = ::FromString( sVal, m_bInvert) ;
      break ;
   case KEY_LICL :
      bOk = ::FromString( sVal, m_dLiCompLen) ;
      break ;
   case KEY_LIEL :
      bOk = ::FromString( sVal, m_dLiElev) ;
      break ;
   case KEY_LIPR :
      bOk = ::FromString( sVal, m_dLiPerp) ;
      break ;
   case KEY_LITG :
      bOk = ::FromString( sVal, m_dLiTan) ;
      break ;
   case KEY_LITY :
      bOk = ::FromString( sVal, m_nLeadInType) ;
      break ;
   case KEY_LOCL :
      bOk = ::FromString( sVal, m_dLoCompLen) ;
      break ;
   case KEY_LOEL :
      bOk = ::FromString( sVal, m_dLoElev) ;
      break ;
   case KEY_LOPR :
      bOk = ::FromString( sVal, m_dLoPerp) ;
      break ;
   case KEY_LOTG :
      bOk = ::FromString( sVal, m_dLoTan) ;
      break ;
   case KEY_LOTY :
      bOk = ::FromString( sVal, m_nLeadOutType) ;
      break ;
   case KEY_LT :
      bOk = ::FromString( sVal, m_bLeaveTab) ;
      break ;
   case KEY_NAME :
      m_sName = sVal ;
      bOk = ! m_sName.empty() ;
      break ;
   case KEY_OL :
      bOk = ::FromString( sVal, m_dOverlap) ;
      break ;
   case KEY_OM :
      bOk = ::FromString( sVal, m_dOverMat) ;
      break ;
   case KEY_SA :
      bOk = ::FromString( sVal, m_dSideAngle) ;
      break ;
   case KEY_ST :
      bOk = ::FromString( sVal, m_dStep) ;
      break ;
   case KEY_STY :
      bOk = ::FromString( sVal, m_nStepType) ;
      break ;
   case KEY_TA :
      bOk = ::FromString( sVal, m_dTabAngle) ;
      break ;
   case KEY_TD :
      bOk = ::FromString( sVal, m_dTabDist) ;
      break ;
   case KEY_TH :
      bOk = ::FromString( sVal, m_dTabHeight) ;
      break ;
   case KEY_TL :
      bOk = ::FromString( sVal, m_dTabLen) ;
      break ;
   case KEY_TNAME :
      m_sToolName = sVal ;
      bOk = ! m_sToolName.empty() ;
      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
MillingData::ToString( int nInd) const
{
   switch ( nInd) {
   case KEY_DH : return ( sMillingKey[KEY_DH] + "=" + ::ToString( m_dDepth)) ;
   case KEY_INV : return ( sMillingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
   case KEY_LICL : return ( sMillingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ;
   case KEY_LIEL : return ( sMillingKey[KEY_LIEL] + "=" + ::ToString( m_dLiElev)) ;
   case KEY_LIPR : return ( sMillingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ;
   case KEY_LITG : return ( sMillingKey[KEY_LITG] + "=" + ::ToString( m_dLiTan)) ;
   case KEY_LITY : return ( sMillingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ;
   case KEY_LOCL : return ( sMillingKey[KEY_LOCL] + "=" + ::ToString( m_dLoCompLen)) ;
   case KEY_LOEL : return ( sMillingKey[KEY_LOEL] + "=" + ::ToString( m_dLoElev)) ;
   case KEY_LOPR : return ( sMillingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ;
   case KEY_LOTG : return ( sMillingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTan)) ;
   case KEY_LOTY : return ( sMillingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ;
   case KEY_LT : return ( sMillingKey[KEY_LT] + "=" + ::ToString( m_bLeaveTab)) ;
   case KEY_NAME : return ( sMillingKey[KEY_NAME] + "=" + m_sName) ;
   case KEY_OL : return ( sMillingKey[KEY_OL] + "=" + ::ToString( m_dOverlap)) ;
   case KEY_OM : return ( sMillingKey[KEY_OM] + "=" + ::ToString( m_dOverMat)) ;
   case KEY_SA : return ( sMillingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
   case KEY_ST : return ( sMillingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
   case KEY_STY : return ( sMillingKey[KEY_STY] + "=" + ::ToString( m_nStepType)) ;
   case KEY_TA : return ( sMillingKey[KEY_TA] + "=" + ::ToString( m_dTabAngle)) ;
   case KEY_TD : return ( sMillingKey[KEY_TD] + "=" + ::ToString( m_dTabDist)) ;
   case KEY_TH : return ( sMillingKey[KEY_TH] + "=" + ::ToString( m_dTabHeight)) ;
   case KEY_TL : return ( sMillingKey[KEY_TL] + "=" + ::ToString( m_dTabLen)) ;
   case KEY_TNAME : return ( sMillingKey[KEY_TNAME] + "=" + m_sToolName) ;
   case KEY_TUUID : return ( sMillingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
   case KEY_UUID : return ( sMillingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
   case KEY_WS : return ( sMillingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ;
   default : return "" ;
   }
}