From 64ed8babd193ee92bae42f6de8a5b8b360f41437 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Sat, 6 Jun 2015 17:50:38 +0000 Subject: [PATCH] EgtMachKernel 1.6f1 : - aggiunta gestione DB utensili - aggiunta gestione DB lavorazioni. --- Disposition.cpp | 4 +- Drilling.cpp | 6 +- Drilling.h | 27 +-- DrillingData.cpp | 151 +++++++++++++++ DrillingData.h | 42 ++++ EgtMachKernel.vcxproj | 14 ++ EgtMachKernel.vcxproj.filters | 93 +++++++-- MachConst.h | 8 + MachMgr.h | 37 ++-- MachMgrBasic.cpp | 8 +- MachMgrMachines.cpp | 80 ++++---- MachineLua.cpp | 14 +- MachiningData.h | 45 +++++ MachiningDataFactory.h | 89 +++++++++ MachiningsMgr.cpp | 347 ++++++++++++++++++++++++++++++++++ MachiningsMgr.h | 56 ++++++ MillingData.cpp | 247 ++++++++++++++++++++++++ MillingData.h | 61 ++++++ SawingData.cpp | 151 +++++++++++++++ SawingData.h | 43 +++++ ToolData.cpp | 231 ++++++++++++++++++++++ ToolData.h | 78 ++++++++ ToolsMgr.cpp | 332 ++++++++++++++++++++++++++++++++ ToolsMgr.h | 54 ++++++ 24 files changed, 2124 insertions(+), 94 deletions(-) create mode 100644 DrillingData.cpp create mode 100644 DrillingData.h create mode 100644 MachiningData.h create mode 100644 MachiningDataFactory.h create mode 100644 MachiningsMgr.cpp create mode 100644 MachiningsMgr.h create mode 100644 MillingData.cpp create mode 100644 MillingData.h create mode 100644 SawingData.cpp create mode 100644 SawingData.h create mode 100644 ToolData.cpp create mode 100644 ToolData.h create mode 100644 ToolsMgr.cpp create mode 100644 ToolsMgr.h diff --git a/Disposition.cpp b/Disposition.cpp index ef057a0..d176f01 100644 --- a/Disposition.cpp +++ b/Disposition.cpp @@ -261,13 +261,13 @@ Disposition::Apply(void) switch ( iIter->nType) { case MoveRawData::COR : if ( ! MoveToCornerRawPart( iIter->nRawId, iIter->ptP, iIter->nFlag, false)) { - string sOut = "Error in MovoToCornerRawPart " + ToString( iIter->nRawId) ; + string sOut = "Error in MoveToCornerRawPart " + ToString( iIter->nRawId) ; LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; } break ; case MoveRawData::CEN : if ( ! MoveToCenterRawPart( iIter->nRawId, iIter->ptP, iIter->nFlag, false)) { - string sOut = "Error in MovoToCenterRawPart " + ToString( iIter->nRawId) ; + string sOut = "Error in MoveToCenterRawPart " + ToString( iIter->nRawId) ; LOG_ERROR( GetEMkLogger(), sOut.c_str()) ; } break ; diff --git a/Drilling.cpp b/Drilling.cpp index 6368497..901fde7 100644 --- a/Drilling.cpp +++ b/Drilling.cpp @@ -59,7 +59,7 @@ bool Drilling::Dump( string& sOut, const char* szNewLine) const { sOut += GetClassName() + szNewLine ; - sOut += DRI_IDS + EQUAL + ToString( m_Params.m_vId) + szNewLine ; + sOut += DRI_IDS + EQUAL + ToString( m_vId) + szNewLine ; sOut += DRI_INV + EQUAL + ToString( m_Params.m_bInvert) + szNewLine ; sOut += DRI_SPS + EQUAL + ToString( m_Params.m_dStartPos) + szNewLine ; sOut += DRI_SSL + EQUAL + ToString( m_Params.m_dStartSlowLen) + szNewLine ; @@ -77,7 +77,7 @@ Drilling::Save( STRVECTOR& vString) const { try { vString.insert( vString.begin(), 8, "") ; - if ( ! SetVal( DRI_IDS, m_Params.m_vId, vString[0]) || + if ( ! SetVal( DRI_IDS, m_vId, vString[0]) || ! SetVal( DRI_INV, m_Params.m_bInvert, vString[1]) || ! SetVal( DRI_SPS, m_Params.m_dStartPos, vString[2]) || ! SetVal( DRI_SSL, m_Params.m_dStartSlowLen, vString[3]) || @@ -99,7 +99,7 @@ Drilling::Load( const STRVECTOR& vString) { if ( vString.size() < 8) return false ; - if ( ! GetVal( vString[0], DRI_IDS, m_Params.m_vId) || + if ( ! GetVal( vString[0], DRI_IDS, m_vId) || ! GetVal( vString[1], DRI_INV, m_Params.m_bInvert) || ! GetVal( vString[2], DRI_SPS, m_Params.m_dStartPos) || ! GetVal( vString[3], DRI_SSL, m_Params.m_dStartSlowLen) || diff --git a/Drilling.h b/Drilling.h index ec99e3f..defaa5d 100644 --- a/Drilling.h +++ b/Drilling.h @@ -20,7 +20,6 @@ //---------------------------------------------------------------------------- struct DrillingParams { - INTVECTOR m_vId ; // indici entità geometriche da lavorare bool m_bInvert ; // flag di inversione direzione lavorazione per fori aperti double m_dStartPos ; // quota di inizio lavorazione (sempre >= 0) double m_dStartSlowLen ; // lunghezza rallentamento iniziale @@ -29,14 +28,6 @@ struct DrillingParams double m_dStep ; // passo di affondameto (0=nessun passo) double m_dReturnPos ; // quota di ritorno (+=fuori, -=dentro) } ; -static std::string DRI_IDS = "Ids" ; -static std::string DRI_INV = "Inv" ; -static std::string DRI_SPS = "Sps" ; -static std::string DRI_SSL = "Ssl" ; -static std::string DRI_ESL = "Esl" ; -static std::string DRI_TAL = "Tal" ; -static std::string DRI_STP = "Stp" ; -static std::string DRI_RPS = "Rps" ; //---------------------------------------------------------------------------- struct DrillBitParams @@ -54,10 +45,21 @@ struct DrillBitParams double m_dStartFeed ; // velocità di lavorazione iniziale double m_dEndFeed ; // velocità di lavorazione finale double m_dDiam ; // diametro + double m_dTDiam ; // diametro totale (di ingombro) double m_dLen ; // lunghezza controllata - double m_dTLen ; // lunghezza totale + double m_dTLen ; // lunghezza totale (di ingombro) } ; +//---------------------------------------------------------------------------- +static std::string DRI_IDS = "Ids" ; +static std::string DRI_INV = "Inv" ; +static std::string DRI_SPS = "Sps" ; +static std::string DRI_SSL = "Ssl" ; +static std::string DRI_ESL = "Esl" ; +static std::string DRI_TAL = "Tal" ; +static std::string DRI_STP = "Stp" ; +static std::string DRI_RPS = "Rps" ; + //---------------------------------------------------------------------------- class Drilling : public IObjUser { @@ -79,6 +81,7 @@ class Drilling : public IObjUser private : int m_nOwnerId ; IGeomDB* m_pGeomDB ; - DrillingParams m_Params ; - DrillBitParams m_TParams ; + INTVECTOR m_vId ; // identificativi entità geometriche da lavorare + DrillingParams m_Params ; // parametri lavorazione + DrillBitParams m_TParams ; // parametri utensile } ; \ No newline at end of file diff --git a/DrillingData.cpp b/DrillingData.cpp new file mode 100644 index 0000000..bbbbfea --- /dev/null +++ b/DrillingData.cpp @@ -0,0 +1,151 @@ +//---------------------------------------------------------------------------- +// 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/EGnStringUtils.h" +#include +#include + +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 sDrillingKey = { + "INV", + "LAT", + "LSE", + "LSS", + "NAME", + "PR", + "PS", + "ST", + "TN", + "TU", + "UUID"} ; + +//---------------------------------------------------------------------------- +MCHDATA_REGISTER( "DRILLING", DrillingData) ; + +//---------------------------------------------------------------------------- +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 ; + bOk = ! m_sToolName.empty() ; + 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 "" ; + } +} \ No newline at end of file diff --git a/DrillingData.h b/DrillingData.h new file mode 100644 index 0000000..e7aac39 --- /dev/null +++ b/DrillingData.h @@ -0,0 +1,42 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : DrillingData.h Data : 04.06.15 Versione : 1.6f1 +// Contenuto : Dichiarazione della struct DrillingData e costanti associate. +// +// +// +// Modifiche : 04.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "MachiningData.h" + +//---------------------------------------------------------------------------- +struct DrillingData : public MachiningData +{ + EgtUUID m_ToolUuid ; // identificativo universale dell'utensile + std::string m_sToolName ; // nome dell'utensile + bool m_bInvert ; // flag di inversione direzione lavorazione per fori aperti + double m_dStartPos ; // quota di inizio lavorazione (sempre >= 0) + double m_dStartSlowLen ; // lunghezza rallentamento iniziale + double m_dEndSlowLen ; // lunghezza rallentamento finale + double m_dThroughAddLen ; // lunghezza aggiuntiva di foratura se passante + double m_dStep ; // passo di affondameto (0=nessun passo) + double m_dReturnPos ; // quota di ritorno (+=fuori, -=dentro) + DrillingData( void) + : m_ToolUuid(), m_bInvert( false), m_dStartPos( 0), m_dStartSlowLen( 0), m_dEndSlowLen( 0), + m_dThroughAddLen( 0), m_dStep( 0), m_dReturnPos( 0) {} + virtual int GetType( void) const { return MT_DRILLING ; } + virtual int GetSize( void) const ; + virtual std::string GetTitle( void) const ; + virtual bool FromString( const std::string& sString, int& nKey) ; + virtual std::string ToString( int nInd) const ; +} ; + +//---------------------------------------------------------------------------- +inline const DrillingData* GetDrillingData( const MachiningData* pMdata) + { return (dynamic_cast( pMdata)) ; } diff --git a/EgtMachKernel.vcxproj b/EgtMachKernel.vcxproj index 1e1ed13..e3e42bf 100644 --- a/EgtMachKernel.vcxproj +++ b/EgtMachKernel.vcxproj @@ -212,6 +212,7 @@ copy $(TargetPath) \EgtProg\Dll64 false + @@ -220,6 +221,7 @@ copy $(TargetPath) \EgtProg\Dll64 + @@ -227,6 +229,8 @@ copy $(TargetPath) \EgtProg\Dll64 + + Create Create @@ -235,6 +239,8 @@ copy $(TargetPath) \EgtProg\Dll64 + + @@ -243,16 +249,24 @@ copy $(TargetPath) \EgtProg\Dll64 + + + + + + + + diff --git a/EgtMachKernel.vcxproj.filters b/EgtMachKernel.vcxproj.filters index 9914b93..3b19acc 100644 --- a/EgtMachKernel.vcxproj.filters +++ b/EgtMachKernel.vcxproj.filters @@ -25,6 +25,15 @@ {3e3114d1-29a3-4acb-8f29-916ef8d05592} + + {7bf2c2ca-8a20-4137-8c02-bbc6231437d9} + + + {bef76ed3-d9cb-4ddf-9dfd-ac83f328473a} + + + {9ebd88f4-45ef-477d-b613-d142baef86fb} + @@ -33,27 +42,6 @@ Source Files\General - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - Source Files\Machine @@ -90,6 +78,45 @@ Source Files\Operations + + Source Files\MachMgr + + + Source Files\MachMgr + + + Source Files\MachMgr + + + Source Files\MachMgr + + + Source Files\MachMgr + + + Source Files\MachMgr + + + Source Files\MachMgr + + + Source Files\Tools + + + Source Files\Machinings + + + Source Files\Tools + + + Source Files\Machinings + + + Source Files\Machinings + + + Source Files\Machinings + @@ -140,6 +167,30 @@ Header Files + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + diff --git a/MachConst.h b/MachConst.h index f97ed66..6bdff10 100644 --- a/MachConst.h +++ b/MachConst.h @@ -45,6 +45,14 @@ const std::string FIXTURES_DIR = "Fixtures" ; //---------------------------------------------------------------------------- // Nome sottodirettorio degli utensili const std::string TOOLS_DIR = "Tools" ; +// Nome file degli utensili +const std::string TOOLS_FILE = "Tools.data" ; + +//---------------------------------------------------------------------------- +// Nome sottodirettorio delle lavorazioni +const std::string MACHININGS_DIR = "Machinings" ; +// Nome file delle lavorazioni +const std::string MACHININGS_FILE = "Machinings.data" ; //---------------------------------------------------------------------------- // Minimo spessore del grezzo diff --git a/MachMgr.h b/MachMgr.h index d45afb3..adfad79 100644 --- a/MachMgr.h +++ b/MachMgr.h @@ -15,6 +15,8 @@ #include "MachConst.h" #include "Machine.h" +#include "ToolsMgr.h" +#include "MachiningsMgr.h" #include "/EgtDev/Include/EMkMachMgr.h" #include "/EgtDev/Include/EgtNumCollection.h" @@ -34,6 +36,17 @@ struct MachGrp { RawGroupId( RgId), OperGroupId( OgId) {} } ; +//---------------------------------------------------------------------------- +struct MachineData { + Machine* pMachine ; + ToolsMgr* pTsMgr ; + MachiningsMgr* pMsMgr ; + MachineData( void) + : pMachine( nullptr), pTsMgr( nullptr), pMsMgr( nullptr) {} + MachineData( Machine* pM, ToolsMgr* pTM, MachiningsMgr* pMM) + { pMachine = pM ; pTsMgr = pTM ; pMsMgr = pMM ; } +} ; + //---------------------------------------------------------------------------- class MachMgr : public IMachMgr { @@ -168,18 +181,18 @@ class MachMgr : public IMachMgr bool ShowRootParts( bool bShow) ; private : - typedef std::vector MCHPVECTOR ; + typedef std::vector MCHDATAVECTOR ; private : - int m_nContextId ; // indice contesto corrente (1-based) - IGeomDB* m_pGeomDB ; // puntatore al DB geometrico del contesto corrente - std::string m_sMachinesDir ; // direttorio delle macchine - std::string m_sLuaLibsDir ; // direttorio delle librerie lua - std::string m_sLuaLastRequire ; // nome ultima libreria caricata - int m_nMachBaseId ; // identificativo gruppo base per le macchinate - int m_nMachAuxId ; // identificativo gruppo base per le macchine - int m_nCurrMGrpId ; // identificativo macchinata corrente - MachGrp m_cCurrMGrp ; // dati principali macchinata corrente - int m_nCurrMch ; // indice macchina corrente (0-based) - MCHPVECTOR m_vMachines ; // elenco macchine caricate + int m_nContextId ; // indice contesto corrente (1-based) + IGeomDB* m_pGeomDB ; // puntatore al DB geometrico del contesto corrente + std::string m_sMachinesDir ; // direttorio delle macchine + std::string m_sLuaLibsDir ; // direttorio delle librerie lua + std::string m_sLuaLastRequire ; // nome ultima libreria caricata + int m_nMachBaseId ; // identificativo gruppo base per le macchinate + int m_nMachAuxId ; // identificativo gruppo base per le macchine + int m_nCurrMGrpId ; // identificativo macchinata corrente + MachGrp m_cCurrMGrp ; // dati principali macchinata corrente + int m_nCurrMch ; // indice macchina corrente (0-based) + MCHDATAVECTOR m_vMachines ; // elenco macchine caricate } ; diff --git a/MachMgrBasic.cpp b/MachMgrBasic.cpp index 666589d..fdb70f2 100644 --- a/MachMgrBasic.cpp +++ b/MachMgrBasic.cpp @@ -61,8 +61,12 @@ MachMgr::Clear( void) { // pulisco le macchine while ( ! m_vMachines.empty()) { - if ( m_vMachines.back() != nullptr) - delete m_vMachines.back() ; + if ( m_vMachines.back().pMachine != nullptr) + delete m_vMachines.back().pMachine ; + if ( m_vMachines.back().pTsMgr != nullptr) + delete m_vMachines.back().pTsMgr ; + if ( m_vMachines.back().pMsMgr != nullptr) + delete m_vMachines.back().pMsMgr ; m_vMachines.pop_back() ; } } diff --git a/MachMgrMachines.cpp b/MachMgrMachines.cpp index edfa51d..0e052a2 100644 --- a/MachMgrMachines.cpp +++ b/MachMgrMachines.cpp @@ -15,6 +15,9 @@ #include "stdafx.h" #include "MachMgr.h" #include "MachConst.h" +#include "ToolsMgr.h" +#include "MachiningsMgr.h" +#include "SawingData.h" #include "/EgtDev/Include/EGkGdbIterator.h" #include "/EgtDev/Include/EgnStringUtils.h" #include "/EgtDev/Include/EgnFileUtils.h" @@ -35,16 +38,23 @@ MachMgr::LoadMachine( const string& sMachineName) // creo gruppo ausiliario di base per le macchine if ( ! CreateMachAux()) return false ; - // creo una nuova macchina + // creo e carico la macchina PtrOwner pMch( new( nothrow) Machine) ; - if ( IsNull( pMch)) + if ( IsNull( pMch) || ! pMch->Init( m_sMachinesDir, sMachineName, this)) return false ; - // tento di caricarla - if ( pMch->Init( m_sMachinesDir, sMachineName, this)) { - m_vMachines.push_back( Release( pMch)) ; - return true ; - } - return false ; + // creo e carico il DB utensili + PtrOwner pTsMgr( new( nothrow) ToolsMgr) ; + string sToolsFile = m_sMachinesDir + "\\" + sMachineName + "\\" + TOOLS_DIR + "\\" + TOOLS_FILE ; + if ( IsNull( pTsMgr) || ! pTsMgr->Init( sToolsFile) || ! pTsMgr->Load()) + return false ; + // creo e carico il DB lavorazioni + PtrOwner pMsMgr( new( nothrow) MachiningsMgr) ; + string sMachsFile = m_sMachinesDir + "\\" + sMachineName + "\\" + MACHININGS_DIR + "\\" + MACHININGS_FILE ; + if ( IsNull( pMsMgr) || ! pMsMgr->Init( sMachsFile) || ! pMsMgr->Load()) + return false ; + // salvo nel vettore + m_vMachines.emplace_back( Release( pMch), Release( pTsMgr), Release( pMsMgr)) ; + return true ; } //---------------------------------------------------------------------------- @@ -53,8 +63,8 @@ MachMgr::GetMachine( const string& sMachineName) const { // ciclo sulle macchine for ( size_t i = 0 ; i < m_vMachines.size() ; ++ i) { - if ( m_vMachines[i] != nullptr && - EqualNoCase( m_vMachines[i]->GetMachineName(), sMachineName)) + if ( m_vMachines[i].pMachine != nullptr && + EqualNoCase( m_vMachines[i].pMachine->GetMachineName(), sMachineName)) return int( i) ; } return - 1 ; @@ -65,9 +75,9 @@ int MachMgr::GetCurrMGeoId( void) const { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return GDB_ID_NULL ; - return m_vMachines[m_nCurrMch]->GetMGeoId() ; + return m_vMachines[m_nCurrMch].pMachine->GetMGeoId() ; } //---------------------------------------------------------------------------- @@ -76,7 +86,7 @@ MachMgr::GetCurrMachine( void) const { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size())) return nullptr ; - return m_vMachines[m_nCurrMch] ; + return m_vMachines[m_nCurrMch].pMachine ; } //---------------------------------------------------------------------------- @@ -84,9 +94,9 @@ bool MachMgr::SetAxisPos( const string& sAxis, double dVal) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return GDB_ID_NULL ; - return m_vMachines[m_nCurrMch]->SetAxisPos( sAxis, dVal) ; + return m_vMachines[m_nCurrMch].pMachine->SetAxisPos( sAxis, dVal) ; } //---------------------------------------------------------------------------- @@ -94,9 +104,9 @@ bool MachMgr::GetAxisPos( const string& sAxis, double& dVal) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return GDB_ID_NULL ; - return m_vMachines[m_nCurrMch]->GetAxisPos( sAxis, dVal) ; + return m_vMachines[m_nCurrMch].pMachine->GetAxisPos( sAxis, dVal) ; } //---------------------------------------------------------------------------- @@ -104,9 +114,9 @@ bool MachMgr::GetAxisHomePos( const string& sAxis, double& dHomeVal) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return GDB_ID_NULL ; - return m_vMachines[m_nCurrMch]->GetAxisHomePos( sAxis, dHomeVal) ; + return m_vMachines[m_nCurrMch].pMachine->GetAxisHomePos( sAxis, dHomeVal) ; } //---------------------------------------------------------------------------- @@ -114,9 +124,9 @@ bool MachMgr::ResetAxisPos( const string& sAxis) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return GDB_ID_NULL ; - return m_vMachines[m_nCurrMch]->ResetAxisPos( sAxis) ; + return m_vMachines[m_nCurrMch].pMachine->ResetAxisPos( sAxis) ; } //---------------------------------------------------------------------------- @@ -124,9 +134,9 @@ bool MachMgr::LoadTool( const string& sHead, int nExit, const string& sTool) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return false ; - return m_vMachines[m_nCurrMch]->LoadTool( sHead, nExit, sTool) ; + return m_vMachines[m_nCurrMch].pMachine->LoadTool( sHead, nExit, sTool) ; } //---------------------------------------------------------------------------- @@ -134,9 +144,9 @@ bool MachMgr::ResetHeadSet( const string& sHead) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return false ; - return m_vMachines[m_nCurrMch]->ResetHeadSet( sHead) ; + return m_vMachines[m_nCurrMch].pMachine->ResetHeadSet( sHead) ; } //---------------------------------------------------------------------------- @@ -144,9 +154,9 @@ bool MachMgr::SetCalcTable( const string& sTable) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return false ; - return m_vMachines[m_nCurrMch]->SetCurrTable( sTable) ; + return m_vMachines[m_nCurrMch].pMachine->SetCurrTable( sTable) ; } //---------------------------------------------------------------------------- @@ -154,9 +164,9 @@ bool MachMgr::SetCalcTool( const string& sTool, const string& sHead, int nExit) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return false ; - return m_vMachines[m_nCurrMch]->SetCurrTool( sTool, sHead, nExit) ; + return m_vMachines[m_nCurrMch].pMachine->SetCurrTool( sTool, sHead, nExit) ; } //---------------------------------------------------------------------------- @@ -165,9 +175,9 @@ MachMgr::GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA, int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return false ; - return m_vMachines[m_nCurrMch]->GetAngles( vtDirT, vtDirA, nStat, dAngA1, dAngB1, dAngA2, dAngB2) ; + return m_vMachines[m_nCurrMch].pMachine->GetAngles( vtDirT, vtDirA, nStat, dAngA1, dAngB1, dAngA2, dAngB2) ; } //---------------------------------------------------------------------------- @@ -176,9 +186,9 @@ MachMgr::GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB, int& nStat, double& dX, double& dY, double& dZ) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return false ; - return m_vMachines[m_nCurrMch]->GetPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) ; + return m_vMachines[m_nCurrMch].pMachine->GetPositions( ptP, dAngA, dAngB, nStat, dX, dY, dZ) ; } //---------------------------------------------------------------------------- @@ -186,7 +196,7 @@ bool MachMgr::VerifyOutOfStroke( double dX, double dY, double dZ, double dAngA, double dAngB, int& nStat) { if ( m_nCurrMch < 0 || m_nCurrMch >= int( m_vMachines.size()) || - m_vMachines[m_nCurrMch] == nullptr) + m_vMachines[m_nCurrMch].pMachine == nullptr) return false ; - return m_vMachines[m_nCurrMch]->VerifyOutOfStroke( dX, dY, dZ, dAngA, dAngB, nStat) ; + return m_vMachines[m_nCurrMch].pMachine->VerifyOutOfStroke( dX, dY, dZ, dAngA, dAngB, nStat) ; } diff --git a/MachineLua.cpp b/MachineLua.cpp index d3c9370..349fac8 100644 --- a/MachineLua.cpp +++ b/MachineLua.cpp @@ -76,7 +76,7 @@ Machine::LuaExecFile( const string& sFile) { // info string sOut = "LuaExecFile : " + sFile ; - ExeOutLog( sOut) ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) // imposto contesto corretto int nOldCtx = ExeGetCurrentContext() ; if ( nOldCtx != m_pMchMgr->GetContextId()) @@ -108,7 +108,7 @@ Machine::LuaEmtGeneral( lua_State* L) // info string sOut = "LuaEmtGeneral : " + sFile ; - ExeOutLog( sOut) ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) // verifico ci sia una macchina attiva if ( m_pMchLua == nullptr) @@ -138,7 +138,7 @@ Machine::LuaEmtBase( lua_State* L) // info string sOut = "LuaEmtBase : " + sName ; - ExeOutLog( sOut) ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) // verifico ci sia una macchina attiva if ( m_pMchLua == nullptr) @@ -177,7 +177,7 @@ Machine::LuaEmtTable( lua_State* L) // info string sOut = "LuaEmtTable : " + sName ; - ExeOutLog( sOut) ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) // verifico ci sia una macchina attiva if ( m_pMchLua == nullptr) @@ -225,7 +225,7 @@ Machine::LuaEmtAxis( lua_State* L) // info string sOut = "LuaEmtAxis : " + sName ; - ExeOutLog( sOut) ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) // verifico ci sia una macchina attiva if ( m_pMchLua == nullptr) @@ -290,7 +290,7 @@ Machine::LuaEmtStdHead( lua_State* L) // info string sOut = "LuaEmtStdHead : " + sName ; - ExeOutLog( sOut) ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) // verifico ci sia una macchina attiva if ( m_pMchLua == nullptr) @@ -346,7 +346,7 @@ Machine::LuaEmtMultiHead( lua_State* L) // info string sOut = "LuaEmtMultiHead : " + sName ; - ExeOutLog( sOut) ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) // verifico ci sia una macchina attiva if ( m_pMchLua == nullptr) diff --git a/MachiningData.h b/MachiningData.h new file mode 100644 index 0000000..913b8fc --- /dev/null +++ b/MachiningData.h @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : MachiningData.h Data : 04.06.15 Versione : 1.6f1 +// Contenuto : Dichiarazione della struct MachiningData e +// delle costanti associate. +// +// +// +// Modifiche : 04.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "/EgtDev/Include/EGnEgtUUID.h" +#include "/EgtDev/Include/EgtStringBase.h" +#include + +//---------------------------------------------------------------------------- +struct MachiningData +{ + EgtUUID m_Uuid ; // identificativo universale della lavorazione + std::string m_sName ; // nome della lavorazione + MachiningData( void) + : m_Uuid() {} + virtual ~MachiningData( void) {} + virtual int GetType( void) const = 0 ; + virtual int GetSize( void) const = 0 ; + virtual std::string GetTitle( void) const = 0 ; + virtual bool FromString( const std::string& sString, int& nKey) = 0 ; + virtual std::string ToString( int nInd) const = 0 ; +} ; + +//---------------------------------------------------------------------------- +// Tipologia di lavorazioni +enum MachiningType { + MT_NONE = 0, + MT_DRILLING = 1, + MT_SAWING = 2, + MT_MILLING = 3, + MT_POCKETING = 4, + MT_MORTISING = 5 +} ; diff --git a/MachiningDataFactory.h b/MachiningDataFactory.h new file mode 100644 index 0000000..47df027 --- /dev/null +++ b/MachiningDataFactory.h @@ -0,0 +1,89 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : MachiningDataFactory.h Data : 05.06.15 Versione : 1.6f1 +// Contenuto : Factory della classe MachiningData. +// +// +// +// Modifiche : 06.05.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "MachiningData.h" +#include +#include + +//---------------------------------------------------------------------------- +#define MCHDATA_REGISTER( sName, T) static const bool bReg_##T = \ + MachiningDataRegister::DoRegister( sName) +#define MCHDATA_GETNAME( T) MachiningDataRegister::GetName() +#define MCHDATA_CREATE( sName) MachiningDataFactory::Create( sName) +#define MCHDATA_GETLIST( vsList) MachiningDataFactory::GetList( vsList) + +//---------------------------------------------------------------------------- +template +class MachiningDataRegister +{ + public : + static bool DoRegister( const std::string& sName) + { if ( ! MachiningDataFactory::Register( sName, Create)) + return false ; + GetNamePrivate() = sName ; + return true ; } + static MachiningData* Create( void) + { return new(nothrow) T ; } + static const std::string& GetName( void) + { return GetNamePrivate() ; } + + private : + MachiningDataRegister( void) {} + ~MachiningDataRegister( void) {} + static std::string& GetNamePrivate( void) + { static std::string s_sName ; + return s_sName ; } +} ; + +//---------------------------------------------------------------------------- +class MachiningDataFactory +{ + public : + // definizione del tipo funzione di creazione + typedef MachiningData* ( *MachiningDataCreator) ( void) ; + // per registrare le funzioni di creazione + static bool Register( const std::string& sName, MachiningDataCreator Creator) + { return GetCreatorMap().emplace( sName, Creator).second ; } + // per creare l'oggetto richiesto + static MachiningData* Create( const std::string& sName) + { auto Iter = GetCreatorMap().find( sName) ; + if ( Iter != GetCreatorMap().end()) { + if ( Iter->second != nullptr) + return Iter->second() ; + } + return nullptr ; + } + // per restituire la lista degli oggetti registrati + static bool GetList( STRVECTOR& vsList) + {// verifico parametro di ritorno + if ( &vsList == nullptr) + return false ; + // ciclo sugli oggetti registrati + for ( auto Iter = GetCreatorMap().cbegin() ; Iter != GetCreatorMap().cend() ; ++ Iter) + vsList.emplace_back( Iter->first) ; + return true ; + } + + private : + MachiningDataFactory( void) {} + ~MachiningDataFactory( void) {} + // definizione del tipo mappa con coppie nome, funzione di creazione + typedef std::unordered_map CreatorMap ; + // metodo di accesso alla mappa statica + static CreatorMap& GetCreatorMap( void) + { static CreatorMap s_CreatorMap ; + return s_CreatorMap ; + } +} ; diff --git a/MachiningsMgr.cpp b/MachiningsMgr.cpp new file mode 100644 index 0000000..4ada72d --- /dev/null +++ b/MachiningsMgr.cpp @@ -0,0 +1,347 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : MachiningsMgr.cpp Data : 02.06.15 Versione : 1.6f1 +// Contenuto : Implementazione gestore database lavorazioni. +// +// +// +// Modifiche : 02.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "MachiningsMgr.h" +#include "MachiningDataFactory.h" +#include "DllMain.h" +#include "/EgtDEv/Include/EGnStringUtils.h" +#include "/EgtDEv/Include/EGnFileUtils.h" +#include "/EgtDEv/Include/EGnScanner.h" +#include "/EgtDEv/Include/EGnWriter.h" +#include "/EgtDEv/Include/EgtPointerOwner.h" +#include +#include + +using namespace std ; + +//---------------------------------------------------------------------------- +const string MF_HEADER = "[HEADER]" ; +const string MF_TOTAL = "TOTAL" ; + + +//---------------------------------------------------------------------------- +MachiningsMgr::MachiningsMgr( void) +{ + m_nCounter = 0 ; +} + +//---------------------------------------------------------------------------- +MachiningsMgr::~MachiningsMgr( void) +{ + // libero la memoria dalle lavorazioni + for ( auto iIter = m_umData.begin() ; iIter != m_umData.end() ; ++ iIter) { + if ( iIter->second != nullptr) + delete iIter->second ; + } + // pulisco le tabelle + m_umData.clear() ; + m_suData.clear() ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::Init( const string& sMachsFile) +{ + // salvo la path del file con i dati + m_sMachsFile = sMachsFile ; + // log + string sOut = "MachiningsMgr Init : " + m_sMachsFile ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) + return true ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::Load( void) +{ + // inizializzo lo scanner + Scanner TheScanner ; + if ( ! TheScanner.Init( m_sMachsFile, ";")) { + LOG_ERROR( GetEMkLogger(), "LoadMachinings : Error on Init") + return false ; + } + + // variabili di stato della lettura + bool bOk = true ; + bool bEnd = false ; + + // leggo l'intestazione + int nTotal = 0 ; + if ( ! LoadHeader( TheScanner, nTotal, bEnd)) { + bOk = false ; + string sOut = "LoadMachinings : Error on Header" ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) + } + + // dimensiono map + const int MIN_BUCKETS = 163 ; + m_umData.rehash( MIN_BUCKETS) ; + + // ciclo di lettura delle lavorazioni + do { + if ( ! LoadOneMachining( TheScanner, bEnd)) { + bOk = false ; + string sOut = "LoadMachinings : Error on line " + ToString( TheScanner.GetCurrLineNbr()) ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) + } + } while ( bOk && ! bEnd) ; + + // termino lo scanner + TheScanner.Terminate() ; + + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::LoadHeader( Scanner& TheScanner, int& nTotal, bool& bEnd) +{ + // leggo la prossima linea + string sLine ; + if ( ! TheScanner.GetLine( sLine)) { + // fine file + bEnd = true ; + return true ; + } + // deve essere intestazione + if ( sLine != MF_HEADER) + return false ; + bool bOk = true ; + // leggo le linee successive + bEnd = true ; + nTotal = 0 ; + while ( bOk && TheScanner.GetLine( sLine)) { + // se utensile successivo + if ( sLine.front() == '[' && sLine.back() == ']') { + TheScanner.UngetLine( sLine) ; + bEnd = false ; + break ; + } + // separo chiave da valore + string sKey, sVal ; + SplitFirst( sLine, "=", sKey, sVal) ; + // riconosco la chiave + if ( ToUpper( sKey) == MF_TOTAL) + bOk = FromString( sVal, nTotal) ; + else + bOk = false ; + } + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::LoadOneMachining( Scanner& TheScanner, bool& bEnd) +{ + // leggo la prossima linea + string sLine ; + if ( ! TheScanner.GetLine( sLine)) { + // fine file + bEnd = true ; + return true ; + } + // deve essere intestazione + if ( sLine.front() != '[' || sLine.back() != ']') + return false ; + Trim( sLine, "[]") ; + // separo tipo da contatore + string sType, sCount ; + SplitFirst( sLine, "_", sType, sCount) ; + ToUpper( sType) ; + // alloco la lavorazione del tipo corrispondente + PtrOwner pMch( MCHDATA_CREATE( sType)) ; + if ( IsNull( pMch)) + return false ; + bool bOk = true ; + // leggo i dati della lavorazione + bEnd = true ; + const int DIM_BS = 64 ; + bitset Flag ; + assert( pMch->GetSize() <= DIM_BS) ; + while ( bOk && TheScanner.GetLine( sLine)) { + // se lavorazione successiva + if ( sLine.front() == '[' && sLine.back() == ']') { + TheScanner.UngetLine( sLine) ; + bEnd = false ; + break ; + } + // interpreto la linea + int nKey = - 1 ; + bOk = pMch->FromString( sLine, nKey) ; + // se tutto bene, dichiaro letto il campo + if ( bOk) + Flag.set( nKey) ; + } + // verifico di aver letto tutti i campi + bOk = bOk && ( Flag.count() == pMch->GetSize()) ; + // salvo i dati della lavorazione + bOk = bOk && m_umData.emplace( pMch->m_Uuid, Get( pMch)).second ; + bOk = bOk && m_suData.emplace( pMch->m_sName, pMch->m_Uuid).second ; + Release( pMch) ; + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::Save( bool bCompressed) const +{ + // faccio copia di backup del file originale + CopyFileEgt( m_sMachsFile, m_sMachsFile + ".bak") ; + + // inizializzo il writer + Writer TheWriter ; + if ( ! TheWriter.Init( m_sMachsFile, bCompressed)) { + LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on Init") + return false ; + } + + // scrivo linea di inizio file + string sOut = "; --- " + m_sMachsFile + " " + CurrDateTime() + " ---" ; + if ( ! TheWriter.OutText( sOut)) { + LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on Start") + return false ; + } + + // scrivo l'intestazione + if ( ! SaveHeader( TheWriter)) { + LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on Header") + return false ; + } + + // ciclo su tutti i nomi delle lavorazioni + for ( auto iIter = m_suData.cbegin() ; iIter != m_suData.cend() ; ++ iIter) { + // salvo l'utensile + if ( ! SaveOneMachining( iIter->second, TheWriter)) { + string sOut = "SaveMachinings : Error on machining " + iIter->first ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) + return false ; + } + } + + // scrivo linea di fine file + if ( ! TheWriter.OutText( "; --- End ---")) { + LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on End") + return false ; + } + + // chiudo la scrittura + TheWriter.Close() ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::SaveHeader( Writer& TheWriter) const +{ + // scrivo l'intestazione + bool bOk = true ; + string sOut ; + sOut = MF_HEADER ; + bOk = bOk && TheWriter.OutText( sOut) ; + sOut = MF_TOTAL + "=" + ToString( int( m_umData.size())) ; + bOk = bOk && TheWriter.OutText( sOut) ; + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::SaveOneMachining( const EgtUUID& Uuid, Writer& TheWriter) const +{ + // recupero i dati della lavorazione + auto iIter = m_umData.find( Uuid) ; + if ( iIter == m_umData.end()) + return false ; + const MachiningData* pmData = iIter->second ; + // scrivo i dati della lavorazione + string sOut = "[" + pmData->GetTitle() + "_" + ToString( ++ m_nCounter, 3) + "]" ; + bool bOk = TheWriter.OutText( sOut) ; + for ( int i = 0 ; i < pmData->GetSize() ; ++ i) { + string sOut = pmData->ToString( i) ; + bOk = bOk && ! sOut.empty() && TheWriter.OutText( sOut) ; + } + return bOk ; +} + +//---------------------------------------------------------------------------- +const MachiningData* +MachiningsMgr::GetMachining( const EgtUUID& Uuid) const +{ + auto iIter = m_umData.find( Uuid) ; + if ( iIter == m_umData.end()) + return nullptr ; + return iIter->second ; +} + +//---------------------------------------------------------------------------- +const MachiningData* +MachiningsMgr::GetMachining( const string& sName) const +{ + auto iIter = m_suData.find( sName) ; + if ( iIter == m_suData.end()) + return nullptr ; + return GetMachining( iIter->second) ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::GetFirstMachining( int nType, string& sName) const +{ + // recupero primo nome + m_suCIter = m_suData.begin() ; + // lo verifico + if ( VerifyCurrMachining( nType, sName)) + return true ; + // continuo ricerca + return GetNextMachining( nType, sName) ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::GetNextMachining( int nType, string& sName) const +{ + // mentre esiste utensile + while ( m_suCIter != m_suData.end()) { + // nome successivo + ++ m_suCIter ; + // lo verifico + if ( VerifyCurrMachining( nType, sName)) + return true ; + } + // non trovato + return false ; +} + +//---------------------------------------------------------------------------- +bool +MachiningsMgr::VerifyCurrMachining( int nType, string& sName) const +{ + // il corrente deve esistere + if ( m_suCIter == m_suData.end()) + return false ; + // relativa lavorazione + auto iIter = m_umData.find( m_suCIter->second) ; + if ( iIter == m_umData.end()) { + m_suCIter = m_suData.end() ; + return false ; + } + // se è del tipo richiesto, trovato + if ( iIter->second->GetType() == nType) { + sName = iIter->second->m_sName ; + return true ; + } + return false ; +} + diff --git a/MachiningsMgr.h b/MachiningsMgr.h new file mode 100644 index 0000000..e9719a1 --- /dev/null +++ b/MachiningsMgr.h @@ -0,0 +1,56 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : MachiningsMgr.h Data : 02.06.15 Versione : 1.6f1 +// Contenuto : Dichiarazione della classe MachiningsMgr. +// +// +// +// Modifiche : 02.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "MachiningData.h" +#include +#include + +class Scanner ; +class Writer ; + +//---------------------------------------------------------------------------- +class MachiningsMgr +{ + public : + MachiningsMgr( void) ; + ~MachiningsMgr( void) ; + bool Init( const std::string& sMachsFile) ; + bool Load( void) ; + bool Save( bool bCompressed = true) const ; + const MachiningData* GetMachining( const EgtUUID& Uuid) const ; + const MachiningData* GetMachining( const std::string& sName) const ; + bool GetFirstMachining( int nType, std::string& sName) const ; + bool GetNextMachining( int nType, std::string& sName) const ; + + private : + bool LoadHeader( Scanner& TheScanner, int& nTotal, bool& bEnd) ; + bool LoadOneMachining( Scanner& TheScanner, bool& bEnd) ; + bool LoadOneDrilling( Scanner& TheScanner, bool& bEnd) ; + bool SaveHeader( Writer& TheWriter) const ; + bool SaveOneMachining( const EgtUUID& Uuid, Writer& TheWriter) const ; + bool VerifyCurrMachining( int nType, std::string& sName) const ; + + private : + typedef std::unordered_map< EgtUUID, MachiningData*> UUIDPMDATA_UMAP ; + typedef std::map< std::string, EgtUUID> STRUUID_MAP ; + typedef STRUUID_MAP::const_iterator STRUUID_CITER ; + + private : + std::string m_sMachsFile ; + UUIDPMDATA_UMAP m_umData ; + STRUUID_MAP m_suData ; + mutable STRUUID_CITER m_suCIter ; + mutable int m_nCounter ; +} ; \ No newline at end of file diff --git a/MillingData.cpp b/MillingData.cpp new file mode 100644 index 0000000..d0eb52c --- /dev/null +++ b/MillingData.cpp @@ -0,0 +1,247 @@ +//---------------------------------------------------------------------------- +// 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 +#include + +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 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 "" ; + } +} \ No newline at end of file diff --git a/MillingData.h b/MillingData.h new file mode 100644 index 0000000..7785862 --- /dev/null +++ b/MillingData.h @@ -0,0 +1,61 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : MillingData.h Data : 05.06.15 Versione : 1.6f1 +// Contenuto : Dichiarazione della struct MillingData e costanti associate. +// +// +// +// Modifiche : 05.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "MachiningData.h" + +//---------------------------------------------------------------------------- +struct MillingData : public MachiningData +{ + EgtUUID m_ToolUuid ; // identificativo universale dell'utensile + std::string m_sToolName ; // nome dell'utensile + bool m_bInvert ; // flag di inversione direzione lavorazione + int m_nWorkSide ; // lato di lavoro (destra, sinistra, centro) + double m_dOverMat ; // sovramateriale radiale + double m_dDepth ; // affondamento + double m_dOverlap ; // lunghezza di sovrapposizione se percorso chiuso + double m_dStep ; // passo di affondamento (0=nessun passo) + int m_nStepType ; // tipo di lavorazione a step (a gradini, una via, a spirale) + double m_dSideAngle ; // angolo di sbandamento (0-60deg) + bool m_bLeaveTab ; // lasciare i tab + double m_dTabLen ; // lunghezza dei tab lasciati per tenere il pezzo + double m_dTabDist ; // distanza tra due tab consecutivi + double m_dTabHeight ; // altezza dei tab + double m_dTabAngle ; // angolo di salita/discesa dei tab + int m_nLeadInType ; // tipo di attacco (nessuno, lineare, tangente, inseguimento) + double m_dLiTan ; // distanza tangente da inizio attacco + double m_dLiPerp ; // distanza perpendicolare da inizio attacco + double m_dLiElev ; // elevazione da inizio attacco + double m_dLiCompLen ; // lunghezza del tratto di inserimento correttore raggio utensile + int m_nLeadOutType ; // tipo di uscita (come attacco, nessuno, lineare, tangente, inseguimento) + double m_dLoTan ; // distanza tangente verso fine uscita + double m_dLoPerp ; // distanza perpendicolare verso fine uscita + double m_dLoElev ; // elevazione verso fine uscita + double m_dLoCompLen ; // lunghezza del tratto di disinserimento correttore raggio utensile + MillingData( void) + : m_bInvert( false), m_nWorkSide( 0), + m_dOverMat( 0), m_dDepth( 0), m_dOverlap( 0), m_dStep( 0), m_nStepType( 0), m_dSideAngle( 0), + m_bLeaveTab( false), m_dTabLen( 0), m_dTabDist( 0), m_dTabHeight( 0), m_dTabAngle( 0), + m_nLeadInType( 0), m_dLiTan( 0), m_dLiPerp( 0), m_dLiElev( 0), m_dLiCompLen( 0), + m_nLeadOutType( 0), m_dLoTan( 0), m_dLoPerp( 0), m_dLoElev( 0), m_dLoCompLen( 0) {} + virtual int GetType( void) const { return MT_MILLING ; } + virtual int GetSize( void) const ; + virtual std::string GetTitle( void) const ; + virtual bool FromString( const std::string& sString, int& nKey) ; + virtual std::string ToString( int nInd) const ; +} ; + +//---------------------------------------------------------------------------- +inline const MillingData* GetMillingData( const MachiningData* pMdata) + { return (dynamic_cast( pMdata)) ; } diff --git a/SawingData.cpp b/SawingData.cpp new file mode 100644 index 0000000..d728b69 --- /dev/null +++ b/SawingData.cpp @@ -0,0 +1,151 @@ +//---------------------------------------------------------------------------- +// 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 "/EgtDev/Include/EGnStringUtils.h" +#include +#include + +using namespace std ; + +//---------------------------------------------------------------------------- +enum nSawingKey { + KEY_DH = 0, + KEY_HS, + KEY_INV, + KEY_NAME, + KEY_SA, + KEY_TAF, + KEY_TNAME, + KEY_TUUID, + KEY_TY, + KEY_UUID, + KEY_WS, + KEY_ZZZ} ; // rappresenta il numero di elementi + +static const std::array sSawingKey = { + "DH", + "HS", + "INV", + "NAME", + "SA", + "TAF", + "TN", + "TU", + "TY", + "UUID", + "WS"} ; + +//---------------------------------------------------------------------------- +MCHDATA_REGISTER( "SAWING", SawingData) ; + +//---------------------------------------------------------------------------- +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_DH : + bOk = ::FromString( sVal, m_dDepth) ; + break ; + case KEY_HS : + bOk = ::FromString( sVal, m_nHeadSide) ; + break ; + case KEY_INV : + bOk = ::FromString( sVal, m_bInvert) ; + break ; + case KEY_NAME : + m_sName = sVal ; + bOk = ! m_sName.empty() ; + break ; + case KEY_SA : + bOk = ::FromString( sVal, m_dSideAngle) ; + break ; + case KEY_TAF : + bOk = ::FromString( sVal, m_bToAndFro) ; + break ; + case KEY_TNAME : + m_sToolName = sVal ; + bOk = ! m_sToolName.empty() ; + break ; + case KEY_TUUID : + bOk = ::FromString( sVal, m_ToolUuid) ; + break ; + case KEY_TY : + bOk = ::FromString( sVal, m_nType) ; + 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_DH : return ( sSawingKey[KEY_DH] + "=" + ::ToString( m_dDepth)) ; + case KEY_HS : return ( sSawingKey[KEY_HS] + "=" + ::ToString( m_nHeadSide)) ; + case KEY_INV : return ( sSawingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; + case KEY_NAME : return ( sSawingKey[KEY_NAME] + "=" + m_sName) ; + case KEY_SA : return ( sSawingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ; + case KEY_TAF : return ( sSawingKey[KEY_TAF] + "=" + ::ToString( m_bToAndFro)) ; + case KEY_TNAME : return ( sSawingKey[KEY_TNAME] + "=" + m_sToolName) ; + case KEY_TUUID : return ( sSawingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; + case KEY_TY : return ( sSawingKey[KEY_TY] + "=" + ::ToString( m_nType)) ; + case KEY_UUID : return ( sSawingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; + case KEY_WS : return ( sSawingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ; + default : return "" ; + } +} diff --git a/SawingData.h b/SawingData.h new file mode 100644 index 0000000..482bcd5 --- /dev/null +++ b/SawingData.h @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : SawingData.h Data : 05.06.15 Versione : 1.6f1 +// Contenuto : Dichiarazione della struct SawingData e costanti associate. +// +// +// +// Modifiche : 05.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "MachiningData.h" + +//---------------------------------------------------------------------------- +struct SawingData : public MachiningData +{ + EgtUUID m_ToolUuid ; // identificativo universale dell'utensile + std::string m_sToolName ; // nome dell'utensile + bool m_bInvert ; // flag di inversione direzione lavorazione + int m_nWorkSide ; // lato di lavoro (destra, sinistra, centro) + int m_nHeadSide ; // lato di posizionamento del mandrino ( destra o sinistra) + int m_nType ; // preciso, centro lama o allungato fino al bordo del grezzo + bool m_bToAndFro ; // taglio avanti-indietro + double m_dDepth ; // affondamento + double m_dSideAngle ; // angolo di sbandamento (0-60deg) + SawingData( void) + : m_bInvert( false), m_nWorkSide( 0), m_nHeadSide(0), m_nType(0), m_bToAndFro( false), + m_dDepth( 0), m_dSideAngle( 0) {} + virtual int GetType( void) const { return MT_SAWING ; } + virtual int GetSize( void) const ; + virtual std::string GetTitle( void) const ; + virtual bool FromString( const std::string& sString, int& nKey) ; + virtual std::string ToString( int nInd) const ; +} ; + +//---------------------------------------------------------------------------- +inline const SawingData* GetSawingData( const MachiningData* pMdata) + { return (dynamic_cast( pMdata)) ; } + diff --git a/ToolData.cpp b/ToolData.cpp new file mode 100644 index 0000000..c4ee4f8 --- /dev/null +++ b/ToolData.cpp @@ -0,0 +1,231 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : ToolData.cpp Data : 04.06.15 Versione : 1.6f1 +// Contenuto : Implementazione struttura dati utensile. +// +// +// +// Modifiche : 04.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "ToolData.h" +#include "/EgtDev/Include/EGnStringUtils.h" +#include +#include + +using namespace std ; + +//---------------------------------------------------------------------------- +enum nToolKey { + TK_COR = 0, + TK_CRAD, + TK_D, + TK_DRAW, + TK_DT, + TK_EXI, + TK_F, + TK_FE, + TK_FS, + TK_FT, + TK_HEA, + TK_L, + TK_LT, + TK_MM, + TK_NAME, + TK_NS, + TK_NU, + TK_OL, + TK_OR, + TK_S, + TK_SANG, + TK_SM, + TK_SUP, + TK_TH, + TK_TYP, + TK_UUID, + TK_ZZZ} ; // rappresenta il numero di elementi + +static const std::array sToolKey = { + "COR", + "CRAD", + "D", + "DRAW", + "DT", + "EXI", + "F", + "FE", + "FS", + "FT", + "HEA", + "L", + "LT", + "MM", + "NAME", + "NS", + "NU", + "OL", + "OR", + "S", + "SANG", + "SM", + "SUP", + "TH", + "TYP", + "UUID"} ; + +//---------------------------------------------------------------------------- +int +ToolData::GetSize( void) const +{ + // in debug verifico validità ultimo campo + assert( sToolKey[TK_UUID] == "UUID") ; + return TK_ZZZ ; +} + +//---------------------------------------------------------------------------- +int +FindToolKey( const string& sKey) +{ + auto TheRange = equal_range( sToolKey.cbegin(), sToolKey.cend(), sKey) ; + if ( TheRange.first == TheRange.second) + return - 1 ; + return int( TheRange.first - sToolKey.cbegin()) ; +} + +//---------------------------------------------------------------------------- +bool +ToolData::FromString( const string& sString, int& nKey) +{ + // separo chiave da valore + string sKey, sVal ; + SplitFirst( sString, "=", sKey, sVal) ; + // riconosco la chiave + nKey = FindToolKey( ToUpper( sKey)) ; + bool bOk = ( nKey >= 0) ; + switch ( nKey) { + case TK_COR : + bOk = ::FromString( sVal, m_nCorr) ; + break ; + case TK_CRAD : + bOk = ::FromString( sVal, m_dCornRad) ; + break ; + case TK_D : + bOk = ::FromString( sVal, m_dDiam) ; + break ; + case TK_DRAW : + m_sDraw = sVal ; + break ; + case TK_DT : + bOk = ::FromString( sVal, m_dTDiam) ; + break ; + case TK_EXI : + bOk = ::FromString( sVal, m_nExit) ; + break ; + case TK_F : + bOk = ::FromString( sVal, m_dFeed) ; + break ; + case TK_FE : + bOk = ::FromString( sVal, m_dEndFeed) ; + break ; + case TK_FS : + bOk = ::FromString( sVal, m_dStartFeed) ; + break ; + case TK_FT : + bOk = ::FromString( sVal, m_dTipFeed) ; + break ; + case TK_HEA : + m_sHead = sVal ; + bOk = ! m_sHead.empty() ; + break ; + case TK_L : + bOk = ::FromString( sVal, m_dLen) ; + break ; + case TK_LT : + bOk = ::FromString( sVal, m_dTLen) ; + break ; + case TK_MM : + bOk = ::FromString( sVal, m_dMaxMat) ; + break ; + case TK_NAME : + m_sName = sVal ; + bOk = ! m_sName.empty() ; + break ; + case TK_NS : + m_sSysNotes = sVal ; + break ; + case TK_NU : + m_sUserNotes = sVal ; + break ; + case TK_OL : + bOk = ::FromString( sVal, m_dOffsL) ; + break ; + case TK_OR : + bOk = ::FromString( sVal, m_dOffsR) ; + break ; + case TK_S : + bOk = ::FromString( sVal, m_dSpeed) ; + break ; + case TK_SANG : + bOk = ::FromString( sVal, m_dSideAng) ; + break ; + case TK_SM : + bOk = ::FromString( sVal, m_dMaxSpeed) ; + break ; + case TK_SUP : + m_sTcPos = sVal ; + break ; + case TK_TH : + bOk = ::FromString( sVal, m_dThick) ; + break ; + case TK_TYP : + bOk = ::FromString( sVal, m_nType) ; + break ; + case TK_UUID : + bOk = ::FromString( sVal, m_Uuid) ; + break ; + default : + bOk = false ; + break ; + } + return bOk ; +} + +//---------------------------------------------------------------------------- +string +ToolData::ToString( int nInd) const +{ + switch ( nInd) { + case TK_COR : return ( sToolKey[TK_COR] + "=" + ::ToString( m_nCorr)) ; + case TK_CRAD : return ( sToolKey[TK_CRAD] + "=" + ::ToString( m_dCornRad)) ; + case TK_D : return ( sToolKey[TK_D] + "=" + ::ToString( m_dDiam)) ; + case TK_DRAW : return ( sToolKey[TK_DRAW] + "=" + m_sDraw) ; + case TK_DT : return ( sToolKey[TK_DT] + "=" + ::ToString( m_dTDiam)) ; + case TK_EXI : return ( sToolKey[TK_EXI] + "=" + ::ToString( m_nExit)) ; + case TK_F : return ( sToolKey[TK_F] + "=" + ::ToString( m_dFeed)) ; + case TK_FE : return ( sToolKey[TK_FE] + "=" + ::ToString( m_dEndFeed)) ; + case TK_FS : return ( sToolKey[TK_FS] + "=" + ::ToString( m_dStartFeed)) ; + case TK_FT : return ( sToolKey[TK_FT] + "=" + ::ToString( m_dTipFeed)) ; + case TK_HEA : return ( sToolKey[TK_HEA] + "=" + m_sHead) ; + case TK_L : return ( sToolKey[TK_L] + "=" + ::ToString( m_dLen)) ; + case TK_LT : return ( sToolKey[TK_LT] + "=" + ::ToString( m_dTLen)) ; + case TK_MM : return ( sToolKey[TK_MM] + "=" + ::ToString( m_dMaxMat)) ; + case TK_NAME : return ( sToolKey[TK_NAME] + "=" + m_sName) ; + case TK_NS : return ( sToolKey[TK_NS] + "=" + m_sSysNotes) ; + case TK_NU : return ( sToolKey[TK_NU] + "=" + m_sUserNotes) ; + case TK_OL : return ( sToolKey[TK_OL] + "=" + ::ToString( m_dOffsL)) ; + case TK_OR : return ( sToolKey[TK_OR] + "=" + ::ToString( m_dOffsR)) ; + case TK_S : return ( sToolKey[TK_S] + "=" + ::ToString( m_dSpeed)) ; + case TK_SANG : return ( sToolKey[TK_SANG] + "=" + ::ToString( m_dSideAng)) ; + case TK_SM : return ( sToolKey[TK_SM] + "=" + ::ToString( m_dMaxSpeed)) ; + case TK_SUP : return ( sToolKey[TK_SUP] + "=" + m_sTcPos) ; + case TK_TH : return ( sToolKey[TK_TH] + "=" + ::ToString( m_dThick)) ; + case TK_TYP : return ( sToolKey[TK_TYP] + "=" + ::ToString( m_nType)) ; + case TK_UUID : return ( sToolKey[TK_UUID] + "=" + ::ToString( m_Uuid)) ; + default : return "" ; + } +} diff --git a/ToolData.h b/ToolData.h new file mode 100644 index 0000000..4a7b6b6 --- /dev/null +++ b/ToolData.h @@ -0,0 +1,78 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : ToolData.h Data : 03.06.15 Versione : 1.6f1 +// Contenuto : Dichiarazione della struct ToolData e costanti associate. +// +// +// +// Modifiche : 03.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "/EgtDev/Include/EGnEgtUUID.h" +#include + +//---------------------------------------------------------------------------- +struct ToolData +{ + EgtUUID m_Uuid ; // identificativo universale dell'utensile + std::string m_sName ; // nome dell'utensile + std::string m_sDraw ; // nome del disegno associato + std::string m_sTcPos ; // posizione di attrezzaggio preferenziale + std::string m_sHead ; // testa di montaggio + int m_nExit ; // uscita di montaggio + int m_nCorr ; // numero di correttore + int m_nType ; // tipo + double m_dMaxSpeed ; // massima velocità di rotazione ammessa (giri/minuto) + double m_dMaxMat ; // massimo materiale + double m_dDiam ; // diametro + double m_dTDiam ; // diametro totale (di ingombro) + double m_dLen ; // lunghezza controllata + double m_dTLen ; // lunghezza totale (di ingombro) + double m_dThick ; // spessore per lame o altezza taglienti + double m_dCornRad ; // raggio corner + double m_dSideAng ; // angolo del fianco rispetto all'asse + double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) + double m_dFeed ; // velocità di lavorazione normale + double m_dStartFeed ; // velocità di lavorazione iniziale + double m_dEndFeed ; // velocità di lavorazione finale + double m_dTipFeed ; // velocità di lavorazione di testa + double m_dOffsR ; // offset radiale + double m_dOffsL ; // offset longitudinale + std::string m_sSysNotes ; // note interne + std::string m_sUserNotes ; // note dell'utente + ToolData( void) + : m_Uuid(), m_nExit( 0), m_nCorr(0), m_nType(0), m_dMaxSpeed(0), m_dMaxMat(0), + m_dDiam( 0), m_dTDiam( 0), m_dLen( 0), m_dTLen( 0), m_dThick( 0), m_dCornRad( 0), m_dSideAng( 0), + m_dSpeed( 0), m_dFeed(0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0), + m_dOffsR( 0), m_dOffsL( 0) {} + int GetSize( void) const ; + bool FromString( const std::string& sString, int& nKey) ; + std::string ToString( int nInd) const ; +} ; + +//---------------------------------------------------------------------------- +// Costanti per famiglie di utensili +const int TF_DRILLBIT = 0x0100 ; // 256 +const int TF_SAWBLADE = 0x0200 ; // 512 +const int TF_MILL = 0x0400 ; // 1024 +const int TF_MORTISE = 0x0800 ; // 2048 +const int TF_COMPO = 0x1000 ; // 4096 + +//---------------------------------------------------------------------------- +// Tipologie di utensili +enum ToolType { + TT_NONE = 0, + TT_DRILL_STD = TF_DRILLBIT + 0, // 256 + TT_DRILL_LONG = TF_DRILLBIT + 1, // 257 + TT_SAW_STD = TF_SAWBLADE + 0, // 512 + TT_SAW_FLAT = TF_SAWBLADE + 1, // 513 + TT_MILL_STD = TF_MILL + 0, // 1024 + TT_MILL_NOTIP = TF_MILL + 1, // 1025 + TT_MORTISE_STD = TF_MORTISE + 0, // 2048 + TT_COMPO = TF_COMPO + 0 // 4096 +} ; diff --git a/ToolsMgr.cpp b/ToolsMgr.cpp new file mode 100644 index 0000000..8648135 --- /dev/null +++ b/ToolsMgr.cpp @@ -0,0 +1,332 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : ToolsMgr.cpp Data : 01.06.15 Versione : 1.6f1 +// Contenuto : Implementazione gestore database utensili. +// +// +// +// Modifiche : 01.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "ToolsMgr.h" +#include "DllMain.h" +#include "/EgtDEv/Include/EGnStringUtils.h" +#include "/EgtDEv/Include/EGnFileUtils.h" +#include "/EgtDEv/Include/EGnScanner.h" +#include "/EgtDEv/Include/EGnWriter.h" +#include +#include + +using namespace std ; + +//---------------------------------------------------------------------------- +const string TF_HEADER = "[HEADER]" ; +const string TF_TOTAL = "TOTAL" ; + +//---------------------------------------------------------------------------- +ToolsMgr::ToolsMgr( void) +{ + m_suCIter = m_suData.cend() ; + m_nCounter = 0 ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::Init( const string& sToolsFile) +{ + // salvo la path del file con i dati + m_sToolsFile = sToolsFile ; + // log + string sOut = "ToolsMgr Init : " + m_sToolsFile ; + LOG_INFO( GetEMkLogger(), sOut.c_str()) + return true ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::Load( void) +{ + // inizializzo lo scanner + Scanner TheScanner ; + if ( ! TheScanner.Init( m_sToolsFile, ";")) { + LOG_ERROR( GetEMkLogger(), "LoadTools : Error on Init") + return false ; + } + + // variabili di stato della lettura + bool bOk = true ; + bool bEnd = false ; + + // leggo l'intestazione + int nTotal = 0 ; + if ( ! LoadHeader( TheScanner, nTotal, bEnd)) { + bOk = false ; + string sOut = "LoadTools : Error on Header" ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) + } + + // dimensiono maps + const int MIN_BUCKETS = 53 ; + m_utData.rehash( MIN_BUCKETS) ; + + // ciclo di lettura degli utensili + do { + if ( ! LoadOneTool( TheScanner, bEnd)) { + bOk = false ; + string sOut = "LoadTools : Error on line " + ToString( TheScanner.GetCurrLineNbr()) ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) + } + } while ( bOk && ! bEnd) ; + + // termino lo scanner + TheScanner.Terminate() ; + + // verifico di aver letto il numero di utensili indicato in header + if ( m_utData.size() != nTotal) { + bOk = false ; + LOG_ERROR( GetEMkLogger(), "LoadTools : Tools number wrong") + } + + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::LoadHeader( Scanner& TheScanner, int& nTotal, bool& bEnd) +{ + // leggo la prossima linea + string sLine ; + if ( ! TheScanner.GetLine( sLine)) { + // fine file + bEnd = true ; + return true ; + } + // deve essere intestazione + if ( sLine != TF_HEADER) + return false ; + bool bOk = true ; + // leggo le linee successive + bEnd = true ; + nTotal = 0 ; + while ( bOk && TheScanner.GetLine( sLine)) { + // se utensile successivo + if ( sLine.front() == '[' && sLine.back() == ']') { + TheScanner.UngetLine( sLine) ; + bEnd = false ; + break ; + } + // separo chiave da valore + string sKey, sVal ; + SplitFirst( sLine, "=", sKey, sVal) ; + // riconosco la chiave + if ( ToUpper( sKey) == TF_TOTAL) + bOk = FromString( sVal, nTotal) ; + else + bOk = false ; + } + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::LoadOneTool( Scanner& TheScanner, bool& bEnd) +{ + ToolData tData ; + // leggo la prossima linea + string sLine ; + if ( ! TheScanner.GetLine( sLine)) { + // fine file + bEnd = true ; + return true ; + } + // deve essere intestazione + if ( sLine.front() != '[' || sLine.back() != ']') + return false ; + // uso temporaneamente come nome utensile + tData.m_sName = sLine.substr( 1, sLine.length() - 2) ; + bool bOk = ! tData.m_sName.empty() ; + // dati successivi + bEnd = true ; + const int DIM_BS = 64 ; + bitset Flag ; + assert( tData.GetSize() <= DIM_BS) ; + while ( bOk && TheScanner.GetLine( sLine)) { + // se utensile successivo + if ( sLine.front() == '[' && sLine.back() == ']') { + TheScanner.UngetLine( sLine) ; + bEnd = false ; + break ; + } + // interpreto la linea + int nKey = - 1 ; + bOk = tData.FromString( sLine, nKey) ; + // se tutto bene, dichiaro letto il campo + if ( bOk) + Flag.set( nKey) ; + } + // verifico di aver letto tutti i campi + bOk = bOk && ( Flag.count() == tData.GetSize()) ; + // salvo i dati dell'utensile + bOk = bOk && m_utData.emplace( tData.m_Uuid, tData).second ; + bOk = bOk && m_suData.emplace( tData.m_sName, tData.m_Uuid).second ; + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::Save( bool bCompressed) const +{ + // faccio copia di backup del file originale + CopyFileEgt( m_sToolsFile, m_sToolsFile + ".bak") ; + + // inizializzo il writer + Writer TheWriter ; + if ( ! TheWriter.Init( m_sToolsFile, bCompressed)) { + LOG_ERROR( GetEMkLogger(), "SaveTools : Error on Init") + return false ; + } + + // scrivo linea di inizio file + string sOut = "; --- " + m_sToolsFile + " " + CurrDateTime() + " ---" ; + if ( ! TheWriter.OutText( sOut)) { + LOG_ERROR( GetEMkLogger(), "SaveTools : Error on Start") + return false ; + } + + // scrivo l'intestazione + if ( ! SaveHeader( TheWriter)) { + LOG_ERROR( GetEMkLogger(), "SaveTools : Error on Header") + return false ; + } + + // ciclo su tutti i nomi degli utensili + m_nCounter = 0 ; + for ( auto iIter = m_suData.cbegin() ; iIter != m_suData.cend() ; ++ iIter) { + // salvo l'utensile + if ( ! SaveOneTool( iIter->second, TheWriter)) { + string sOut = "SaveTools : Error on tool " + iIter->first ; + LOG_ERROR( GetEMkLogger(), sOut.c_str()) + return false ; + } + } + + // scrivo linea di fine file + if ( ! TheWriter.OutText( "; --- End ---")) { + LOG_ERROR( GetEMkLogger(), "SaveTools : Error on End") + return false ; + } + + // chiudo la scrittura + TheWriter.Close() ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::SaveHeader( Writer& TheWriter) const +{ + // scrivo l'intestazione + bool bOk = true ; + string sOut ; + sOut = TF_HEADER ; + bOk = bOk && TheWriter.OutText( sOut) ; + sOut = TF_TOTAL + "=" + ToString( int( m_utData.size())) ; + bOk = bOk && TheWriter.OutText( sOut) ; + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::SaveOneTool( const EgtUUID& Uuid, Writer& TheWriter) const +{ + // recupero i dati dell'utensile + auto iIter = m_utData.find( Uuid) ; + if ( iIter == m_utData.end()) + return false ; + const ToolData& tData = iIter->second ; + // scrivo i dati dell'utensile + string sOut = "[TOOL_" + ToString( ++ m_nCounter, 3) + "]" ; + bool bOk = TheWriter.OutText( sOut) ; + for ( int i = 0 ; i < tData.GetSize() ; ++ i) { + string sOut = tData.ToString( i) ; + bOk = bOk && ! sOut.empty() && TheWriter.OutText( sOut) ; + } + return bOk ; +} + +//---------------------------------------------------------------------------- +const ToolData* +ToolsMgr::GetTool( const EgtUUID& Uuid) const +{ + auto iIter = m_utData.find( Uuid) ; + if ( iIter == m_utData.end()) + return nullptr ; + return &( iIter->second) ; +} + +//---------------------------------------------------------------------------- +const ToolData* +ToolsMgr::GetTool( const string& sName) const +{ + auto iIter = m_suData.find( sName) ; + if ( iIter == m_suData.end()) + return nullptr ; + return GetTool( iIter->second) ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::GetFirstTool( int nFamily, string& sName, int& nType) const +{ + // primo nome + m_suCIter = m_suData.begin() ; + // lo verifico + if ( VerifyCurrTool( nFamily, sName, nType)) + return true ; + // continuo ricerca + return GetNextTool( nFamily, sName, nType) ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::GetNextTool( int nFamily, string& sName, int& nType) const +{ + // mentre esiste utensile + while ( m_suCIter != m_suData.end()) { + // nome successivo + ++ m_suCIter ; + // lo verifico + if ( VerifyCurrTool( nFamily, sName, nType)) + return true ; + } + // non trovato + return false ; +} + +//---------------------------------------------------------------------------- +bool +ToolsMgr::VerifyCurrTool( int nFamily, string& sName, int& nType) const +{ + // il corrente deve esistere + if ( m_suCIter == m_suData.end()) + return false ; + // relativo utensile + auto iIter = m_utData.find( m_suCIter->second) ; + if ( iIter == m_utData.end()) { + m_suCIter = m_suData.end() ; + return false ; + } + // se appartiene alla famiglia richiesta, trovato + if ( ( iIter->second.m_nType & nFamily) != 0) { + sName = iIter->second.m_sName ; + nType = iIter->second.m_nType ; + return true ; + } + return false ; +} diff --git a/ToolsMgr.h b/ToolsMgr.h new file mode 100644 index 0000000..50392d8 --- /dev/null +++ b/ToolsMgr.h @@ -0,0 +1,54 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : ToolsMgr.h Data : 01.06.15 Versione : 1.6f1 +// Contenuto : Dichiarazione della classe ToolsMgr. +// +// +// +// Modifiche : 01.06.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "ToolData.h" +#include +#include + +class Scanner ; +class Writer ; + +//---------------------------------------------------------------------------- +class ToolsMgr +{ + public : + ToolsMgr( void) ; + bool Init( const std::string& sToolsFile) ; + bool Load( void) ; + bool Save( bool bCompressed = true) const ; + const ToolData* GetTool( const EgtUUID& Uuid) const ; + const ToolData* GetTool( const std::string& sName) const ; + bool GetFirstTool( int nFamily, std::string& sName, int& nType) const ; + bool GetNextTool( int nFamily, std::string& sName, int& nType) const ; + + private : + bool LoadHeader( Scanner& TheScanner, int& nTotal, bool& bEnd) ; + bool LoadOneTool( Scanner& TheScanner, bool& bEnd) ; + bool SaveHeader( Writer& TheWriter) const ; + bool SaveOneTool( const EgtUUID& Uuid, Writer& TheWriter) const ; + bool VerifyCurrTool( int nFamily, std::string& sName, int& nType) const ; + + private : + typedef std::unordered_map< EgtUUID, ToolData> UUIDTDATA_UMAP ; + typedef std::map< std::string, EgtUUID> STRUUID_MAP ; + typedef STRUUID_MAP::const_iterator STRUUID_CITER ; + + private : + std::string m_sToolsFile ; + UUIDTDATA_UMAP m_utData ; + STRUUID_MAP m_suData ; + mutable STRUUID_CITER m_suCIter ; + mutable int m_nCounter ; +} ; \ No newline at end of file