Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtMachKernel 1.6f1 :

Browse Source 
- aggiunta gestione DB utensili
- aggiunta gestione DB lavorazioni.
This commit is contained in:
Dario Sassi
2015-06-06 17:50:38 +00:00
parent b373807375
commit 64ed8babd1
24 changed files with 2124 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Disposition.cpp
+2 -2
View File
@@ -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 ;
Drilling.cpp
+3 -3
View File
@@ -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) ||
Drilling.h
+15 -12
View File
@@ -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
} ;
DrillingData.cpp
+151
View File
@@ -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 <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( "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 "" ;
}
}
DrillingData.h
+42
View File
@@ -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<const DrillingData*>( pMdata)) ; }
EgtMachKernel.vcxproj
+14
View File
@@ -212,6 +212,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Drilling.cpp" />
<ClCompile Include="DrillingData.cpp" />
<ClCompile Include="EMkDllMain.cpp" />
<ClCompile Include="Exit.cpp" />
<ClCompile Include="GeoCalc.cpp" />
@@ -220,6 +221,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClCompile Include="MachineCalc.cpp" />
<ClCompile Include="MachineLua.cpp" />
<ClCompile Include="MachineHeads.cpp" />
<ClCompile Include="MachiningsMgr.cpp" />
<ClCompile Include="MachMgrBasic.cpp" />
<ClCompile Include="MachMgrFixtures.cpp" />
<ClCompile Include="MachMgrMachGroups.cpp" />
@@ -227,6 +229,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClCompile Include="MachMgrOperations.cpp" />
<ClCompile Include="MachMgrParts.cpp" />
<ClCompile Include="MachMgrRawParts.cpp" />
<ClCompile Include="MillingData.cpp" />
<ClCompile Include="SawingData.cpp" />
<ClCompile Include="stdafx.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
@@ -235,6 +239,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
</ClCompile>
<ClCompile Include="Head.cpp" />
<ClCompile Include="Table.cpp" />
<ClCompile Include="ToolData.cpp" />
<ClCompile Include="ToolsMgr.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\Include\EMkDllMain.h" />
@@ -243,16 +249,24 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="Disposition.h" />
<ClInclude Include="DllMain.h" />
<ClInclude Include="Drilling.h" />
<ClInclude Include="DrillingData.h" />
<ClInclude Include="Exit.h" />
<ClInclude Include="GeoCalc.h" />
<ClInclude Include="MachConst.h" />
<ClInclude Include="Machine.h" />
<ClInclude Include="MachineStruConst.h" />
<ClInclude Include="MachiningData.h" />
<ClInclude Include="MachiningDataFactory.h" />
<ClInclude Include="MachiningsMgr.h" />
<ClInclude Include="MachMgr.h" />
<ClInclude Include="MillingData.h" />
<ClInclude Include="resource.h" />
<ClInclude Include="SawingData.h" />
<ClInclude Include="stdafx.h" />
<ClInclude Include="Head.h" />
<ClInclude Include="Table.h" />
<ClInclude Include="ToolData.h" />
<ClInclude Include="ToolsMgr.h" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtMachKernel.rc" />
EgtMachKernel.vcxproj.filters
+72 -21
View File
@@ -25,6 +25,15 @@
<Filter Include="Source Files\Operations">
<UniqueIdentifier>{3e3114d1-29a3-4acb-8f29-916ef8d05592}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\MachMgr">
<UniqueIdentifier>{7bf2c2ca-8a20-4137-8c02-bbc6231437d9}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Tools">
<UniqueIdentifier>{bef76ed3-d9cb-4ddf-9dfd-ac83f328473a}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Machinings">
<UniqueIdentifier>{9ebd88f4-45ef-477d-b613-d142baef86fb}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="EMkDllMain.cpp">
@@ -33,27 +42,6 @@
<ClCompile Include="stdafx.cpp">
<Filter>Source Files\General</Filter>
</ClCompile>
<ClCompile Include="MachMgrBasic.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MachMgrMachGroups.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MachMgrRawParts.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MachMgrParts.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MachMgrMachines.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MachMgrFixtures.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="MachMgrOperations.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Axis.cpp">
<Filter>Source Files\Machine</Filter>
</ClCompile>
@@ -90,6 +78,45 @@
<ClCompile Include="Disposition.cpp">
<Filter>Source Files\Operations</Filter>
</ClCompile>
<ClCompile Include="MachMgrBasic.cpp">
<Filter>Source Files\MachMgr</Filter>
</ClCompile>
<ClCompile Include="MachMgrFixtures.cpp">
<Filter>Source Files\MachMgr</Filter>
</ClCompile>
<ClCompile Include="MachMgrMachGroups.cpp">
<Filter>Source Files\MachMgr</Filter>
</ClCompile>
<ClCompile Include="MachMgrMachines.cpp">
<Filter>Source Files\MachMgr</Filter>
</ClCompile>
<ClCompile Include="MachMgrOperations.cpp">
<Filter>Source Files\MachMgr</Filter>
</ClCompile>
<ClCompile Include="MachMgrParts.cpp">
<Filter>Source Files\MachMgr</Filter>
</ClCompile>
<ClCompile Include="MachMgrRawParts.cpp">
<Filter>Source Files\MachMgr</Filter>
</ClCompile>
<ClCompile Include="ToolsMgr.cpp">
<Filter>Source Files\Tools</Filter>
</ClCompile>
<ClCompile Include="MachiningsMgr.cpp">
<Filter>Source Files\Machinings</Filter>
</ClCompile>
<ClCompile Include="ToolData.cpp">
<Filter>Source Files\Tools</Filter>
</ClCompile>
<ClCompile Include="DrillingData.cpp">
<Filter>Source Files\Machinings</Filter>
</ClCompile>
<ClCompile Include="SawingData.cpp">
<Filter>Source Files\Machinings</Filter>
</ClCompile>
<ClCompile Include="MillingData.cpp">
<Filter>Source Files\Machinings</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="DllMain.h">
@@ -140,6 +167,30 @@
<ClInclude Include="Disposition.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="ToolsMgr.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MachiningsMgr.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="ToolData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="DrillingData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MachiningData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="SawingData.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MachiningDataFactory.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="MillingData.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtMachKernel.rc">
MachConst.h
+8
View File
@@ -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
MachMgr.h
+25 -12
View File
@@ -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<Machine*> MCHPVECTOR ;
typedef std::vector<MachineData> 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
} ;
MachMgrBasic.cpp
+6 -2
View File
@@ -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() ;
}
}
MachMgrMachines.cpp
+45 -35
View File
@@ -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<Machine> 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<ToolsMgr> 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<MachiningsMgr> 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) ;
}
MachineLua.cpp
+7 -7
View File
@@ -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)
MachiningData.h
+45
View File
@@ -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 <string>
//----------------------------------------------------------------------------
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
} ;
MachiningDataFactory.h
+89
View File
@@ -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 <string>
#include <unordered_map>
//----------------------------------------------------------------------------
#define MCHDATA_REGISTER( sName, T) static const bool bReg_##T = \
MachiningDataRegister<T>::DoRegister( sName)
#define MCHDATA_GETNAME( T) MachiningDataRegister<T>::GetName()
#define MCHDATA_CREATE( sName) MachiningDataFactory::Create( sName)
#define MCHDATA_GETLIST( vsList) MachiningDataFactory::GetList( vsList)
//----------------------------------------------------------------------------
template <typename T>
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<std::string, MachiningDataCreator> CreatorMap ;
// metodo di accesso alla mappa statica
static CreatorMap& GetCreatorMap( void)
{ static CreatorMap s_CreatorMap ;
return s_CreatorMap ;
}
} ;
MachiningsMgr.cpp
+347
View File
@@ -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 <cassert>
#include <bitset>
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<MachiningData> 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<DIM_BS> 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 ;
}
MachiningsMgr.h
+56
View File
@@ -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 <unordered_map>
#include <map>
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 ;
} ;
MillingData.cpp
+247
View File
@@ -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 <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 "" ;
}
}
MillingData.h
+61
View File
@@ -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<const MillingData*>( pMdata)) ; }
SawingData.cpp
+151
View File
@@ -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 <array>
#include <cassert>
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<std::string,KEY_ZZZ> 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 "" ;
}
}
SawingData.h
+43
View File
@@ -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<const SawingData*>( pMdata)) ; }
ToolData.cpp
+231
View File
@@ -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 <array>
#include <cassert>
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<std::string,TK_ZZZ> 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 "" ;
}
}
ToolData.h
+78
View File
@@ -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 <string>
//----------------------------------------------------------------------------
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
} ;
ToolsMgr.cpp
+332
View File
@@ -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 <cassert>
#include <bitset>
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<DIM_BS> 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 ;
}
ToolsMgr.h
+54
View File
@@ -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 <unordered_map>
#include <map>
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 ;
} ;