Egalware/EgtExchange
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e2ef2a19ef357b1eb79d094a5bcaf7ea4e121c32
EgtExchange/ImportBtl.cpp
T
Dario Sassi 418f11bbc2 EgtExchange : 
- modifiche per gestione travi e pareti da BeamMgr.
2020-12-14 20:52:07 +00:00

1382 lines
45 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : ImportBtl.cpp Data : 22.08.15 Versione : 1.6h5
// Contenuto : Implementazione della classe per l'importazione BTL.
//
//
//
// Modifiche : 22.08.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "ImportBtl.h"
#include "DllMain.h"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGkStmStandard.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgtKeyCodes.h"
#include "/EgtDev/Include/EgtStringEncoder.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//----------------------------------------------------------------------------
// Commento
static const std::string KEY_COMMENT = "COMMENT" ;
// Sezioni
// HEADER non ha intestazione
static const std::string SEC_GENERAL = "[GENERAL]" ;
static const std::string SEC_RAWPART = "[RAWPART]" ;
static const std::string SEC_PART = "[PART]" ;
static const std::string SEC_COMPOSITE = "[COMPOSITE]" ;
// Chiavi HEADER
static const std::string KEY_VERSION = "VERSION" ;
static const std::string KEY_BUILD = "BUILD" ;
static const std::string KEY_EDITION = "EDITION" ;
//--- Chiavi GENERAL ---------------------------------------------------------
enum nGeneKey {
KEY_GENE_ARCHITECT = 0,
KEY_GENE_COMPUTERNAME,
KEY_GENE_CUSTOMER,
KEY_GENE_DELIVERYDATE,
KEY_GENE_EDITOR,
KEY_GENE_EXPORTDATE,
KEY_GENE_EXPORTFILE,
KEY_GENE_EXPORTRELEASE,
KEY_GENE_EXPORTTIME,
KEY_GENE_LANGUAGE,
KEY_GENE_LISTNAME,
KEY_GENE_PROCESSINGQUALITY,
KEY_GENE_PROJECTGUID,
KEY_GENE_PROJECTNAME,
KEY_GENE_PROJECTNUMBER,
KEY_GENE_PROJECTPART,
KEY_GENE_RANGE,
KEY_GENE_RECESS,
KEY_GENE_SCALEUNIT,
KEY_GENE_SOURCEFILE,
KEY_GENE_USER,
KEY_GENE_USERATTRIBUTE,
KEY_GENE_ZZZ
} ;
static const array<string,KEY_GENE_ZZZ> sGeneKey = {
"ARCHITECT",
"COMPUTERNAME",
"CUSTOMER",
"DELIVERYDATE",
"EDITOR",
"EXPORTDATE",
"EXPORTFILE",
"EXPORTRELEASE",
"EXPORTTIME",
"LANGUAGE",
"LISTNAME",
"PROCESSINGQUALITY",
"PROJECTGUID",
"PROJECTNAME",
"PROJECTNUMBER",
"PROJECTPART",
"RANGE",
"RECESS",
"SCALEUNIT",
"SOURCEFILE",
"USER",
"USERATTRIBUTE"
} ;
static int
FindGeneralKey( const string& sKey)
{
auto TheRange = equal_range( sGeneKey.cbegin(), sGeneKey.cend(), sKey) ;
if ( TheRange.first == TheRange.second)
return - 1 ;
return int( TheRange.first - sGeneKey.cbegin()) ;
}
//--- Chiavi RAWPART ---------------------------------------------------------
enum nRawpKey {
KEY_RAWP_PROCESSKEY = 0,
KEY_RAWP_PROCESSPARAMETERS,
KEY_RAWP_REFERENCEPLANE,
KEY_RAWP_ZZZ
} ;
static const array<string,KEY_RAWP_ZZZ> sRawpKey = {
"PROCESSKEY",
"PROCESSPARAMETERS",
"REFERENCEPLANE"
} ;
static int
FindRawPartKey( const string& sKey)
{
auto TheRange = equal_range( sRawpKey.cbegin(), sRawpKey.cend(), sKey) ;
if ( TheRange.first == TheRange.second)
return - 1 ;
return int( TheRange.first - sRawpKey.cbegin()) ;
}
//--- Chiavi PART ------------------------------------------------------------
enum nPartKey {
KEY_PART_ALIGNMENT = 0,
KEY_PART_ANNOTATION,
KEY_PART_APERTURE,
KEY_PART_ASSEMBLYNUMBER,
KEY_PART_CAMBER,
KEY_PART_COLOUR,
KEY_PART_COUNT,
KEY_PART_DESIGNATION,
KEY_PART_ELEMENTNUMBER,
KEY_PART_ENDOFFSET,
KEY_PART_GRAINDIRECTION,
KEY_PART_GROUP,
KEY_PART_HEIGHT,
KEY_PART_LAYER,
KEY_PART_LENGTH,
KEY_PART_MATERIAL,
KEY_PART_MATERIALTYPE,
KEY_PART_MODULENUMBER,
KEY_PART_ORDERNUMBER,
KEY_PART_OUTLINE,
KEY_PART_PACKAGE,
KEY_PART_PARTOFFSET,
KEY_PART_PLANINGLENGTH,
KEY_PART_PROCESSINGQUALITY,
KEY_PART_QUALITYGRADE,
KEY_PART_RECESS,
KEY_PART_REFERENCEPLANE,
KEY_PART_REFERENCESIDE,
KEY_PART_SINGLEMEMBERNUMBER,
KEY_PART_STARTOFFSET,
KEY_PART_STOREY,
KEY_PART_STOREYTYPE,
KEY_PART_TIMBERGRADE,
KEY_PART_TRANSFORMATION,
KEY_PART_UID,
KEY_PART_USERATTRIBUTE,
KEY_PART_WIDTH,
KEY_PART_ZZZ
} ;
static const array<string,KEY_PART_ZZZ> sPartKey = {
"ALIGNMENT",
"ANNOTATION",
"APERTURE",
"ASSEMBLYNUMBER",
"CAMBER",
"COLOUR",
"COUNT",
"DESIGNATION",
"ELEMENTNUMBER",
"ENDOFFSET",
"GRAINDIRECTION",
"GROUP",
"HEIGHT",
"LAYER",
"LENGTH",
"MATERIAL",
"MATERIALTYPE",
"MODULENUMBER",
"ORDERNUMBER",
"OUTLINE",
"PACKAGE",
"PARTOFFSET",
"PLANINGLENGTH",
"PROCESSINGQUALITY",
"QUALITYGRADE",
"RECESS",
"REFERENCEPLANE",
"REFERENCESIDE",
"SINGLEMEMBERNUMBER",
"STARTOFFSET",
"STOREY",
"STOREYTYPE",
"TIMBERGRADE",
"TRANSFORMATION",
"UID",
"USERATTRIBUTE",
"WIDTH"
} ;
static int
FindPartKey( const string& sKey)
{
auto TheRange = equal_range( sPartKey.cbegin(), sPartKey.cend(), sKey) ;
if ( TheRange.first == TheRange.second)
return - 1 ;
return int( TheRange.first - sPartKey.cbegin()) ;
}
//--- Chiavi PROCESS ---------------------------------------------------------
enum nProcKey {
KEY_PROC_PRIORITY = 0,
KEY_PROC_PROCESS,
KEY_PROC_PROCESSIDENT,
KEY_PROC_PROCESSINGQUALITY,
KEY_PROC_PROCESSKEY,
KEY_PROC_PROCESSPARAMETERS,
KEY_PROC_RECESS,
KEY_PROC_REFERENCEPLANE,
KEY_PROC_USERATTRIBUTE,
KEY_PROC_ZZZ
} ;
static const array<string,KEY_PROC_ZZZ> sProcKey = {
"PRIORITY",
"PROCESS",
"PROCESSIDENT",
"PROCESSINGQUALITY",
"PROCESSKEY",
"PROCESSPARAMETERS",
"RECESS",
"REFERENCEPLANE",
"USERATTRIBUTE"
} ;
static int
FindProcessKey( const string& sKey)
{
auto TheRange = equal_range( sProcKey.cbegin(), sProcKey.cend(), sKey) ;
if ( TheRange.first == TheRange.second)
return - 1 ;
return int( TheRange.first - sProcKey.cbegin()) ;
}
// Parametri
static const std::string PAR_R = "R" ;
static const std::string PAR_G = "G" ;
static const std::string PAR_B = "B" ;
static const std::string PAR_A = "A" ;
static const std::string PAR_X = "X" ;
static const std::string PAR_Y = "Y" ;
static const std::string PAR_Z = "Z" ;
static const std::string PAR_ALIGN = "ALIGN" ;
static const std::string PAR_OX = "OX" ;
static const std::string PAR_OY = "OY" ;
static const std::string PAR_OZ = "OZ" ;
static const std::string PAR_XX = "XX" ;
static const std::string PAR_XY = "XY" ;
static const std::string PAR_XZ = "XZ" ;
static const std::string PAR_YX = "YX" ;
static const std::string PAR_YY = "YY" ;
static const std::string PAR_YZ = "YZ" ;
static const std::string PAR_PROCESS = "PROCESS" ;
static const std::string PAR_SIDE = "SIDE" ;
static const std::string PAR_P = "P" ;
//----------------------------------------------------------------------------
IImportBtl*
CreateImportBtl( void)
{
// verifico la chiave e le opzioni
if ( ! TestKeyForEEx( GetEExKey(), KEYOPT_EEX_INPADV, GetEExLogger()))
return nullptr ;
// creo l'oggetto
return static_cast<IImportBtl*> ( new(nothrow) ImportBtl) ;
}
//----------------------------------------------------------------------------
ImportBtl::ImportBtl( void)
{
m_nBuild = 10000 ;
m_dScale = 1 ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::Import( const string& sFile, IGeomDB* pGDB, int nFlag)
{
// log di informazioni
LOG_INFO( GetEExLogger(), ( "ImportBtl : " + sFile).c_str())
// inizializzo lo scanner
if ( ! m_theScanner.Init( sFile, KEY_COMMENT.c_str())) {
LOG_ERROR( GetEExLogger(), " Error on Init")
return false ;
}
// inizializzo il gestore geometria pezzi Btl
int nFlatVertPos = 0 ;
if (( nFlag & EIBFLAG_TS3_POS) != 0)
nFlatVertPos = 3 ;
else if (( nFlag & EIBFLAG_FLAT_POS) != 0)
nFlatVertPos = 1 ;
else if (( nFlag & EIBFLAG_VERT_POS) != 0)
nFlatVertPos = 2 ;
bool bSpecialTrim = (( nFlag & EIBFLAG_SPECIAL_TRIM) != 0) ;
bool bUseUAttr = (( nFlag & EIBFLAG_USEUATTR) != 0) ;
if ( ! m_BtlGeom.Init( pGDB, nFlatVertPos, bSpecialTrim, bUseUAttr)) {
LOG_ERROR( GetEExLogger(), " Error on BtlGeom.Init")
return false ;
}
// scrivo nel progetto path del file
m_BtlGeom.SetUserAttribute( UATD_INFO, IKEY_BTL_PATH + ":" + sFile) ;
// lettura intestazione
if ( ! ReadHeader()) {
string sOut = " Error (ReadHeader) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
return false ;
}
// lettura generalità
if ( ! ReadGeneral()) {
string sOut = " Error (ReadGeneral) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
return false ;
}
// ciclo sui grezzi
bool bOk = true ;
for ( bool bEnd = false ; ! bEnd ;) {
if ( ! ReadRawPart( bEnd)) {
string sOut = " Error (ReadRawPart) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
bOk = false ;
}
}
// ciclo sui pezzi
for ( bool bEnd = false ; ! bEnd ;) {
if ( ! ReadPart( bEnd)) {
// i log di errore sono già gestiti nella funzione chiamata
bOk = false ;
}
}
// ciclo sui compositi
for ( bool bEnd = false ; ! bEnd ;) {
if ( ! ReadComposite( bEnd)) {
string sOut = " Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
bOk = false ;
}
}
// eventuale ordinamento dei pezzi secondo SN
bool bSort = (( nFlag & EIBFLAG_SORT) != 0) ;
if ( bSort)
m_BtlGeom.SortParts() ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadHeader( void)
{
// conteggio campi utili letti
int nRead = 0 ;
// ciclo sulle linee
string sLine ;
while ( m_theScanner.GetLine( sLine)) {
// se cambio sezione
if ( sLine[0] == '[') {
m_theScanner.UngetLine( sLine) ;
return ( nRead > 0) ;
}
// spezzo la linea
string sKey, sVal ;
SplitFirst( sLine, ":", sKey, sVal) ;
// se numero di versione
if ( sKey == KEY_VERSION) {
Trim( sVal, " \t\r\n\"") ;
m_sVersion = sVal ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, m_sVersion) ;
}
// se numero di build
else if ( sKey == KEY_BUILD) {
Trim( sVal, " \t\r\n\"") ;
if ( FromString( sVal, m_nBuild))
++ nRead ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
}
// se edizione
else if ( sKey == KEY_EDITION) {
Trim( sVal, " \t\r\n\"") ;
if ( sVal == "PREFABRICATION")
m_nEdition = 1 ;
else
m_nEdition = 0 ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
}
}
return false ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadGeneral( void)
{
// conteggio campi utili letti
int nRead = 0 ;
// leggo la prossima linea e verifico sia la sezione GENERAL
string sLine ;
if ( ! m_theScanner.GetLine( sLine) || sLine != SEC_GENERAL)
return false ;
// ciclo sulle linee
while ( m_theScanner.GetLine( sLine)) {
// se cambio sezione
if ( sLine[0] == '[') {
m_theScanner.UngetLine( sLine) ;
return ( nRead > 0) ;
}
// spezzo la linea
string sKey, sVal ;
SplitFirst( sLine, ":", sKey, sVal) ;
switch ( FindGeneralKey( sKey)) {
case KEY_GENE_PROJECTNUMBER : // numero di progetto
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_PROJECTNAME : // nome di progetto
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_PROJECTPART : // parte di progetto
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_PROJECTGUID : // identificativo globale unico di progetto
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_LISTNAME : // nome lista
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_CUSTOMER : // cliente
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_ARCHITECT : // architetto
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_EDITOR : // autore
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_DELIVERYDATE : // data di consegna
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_EXPORTDATE : // data di esportazione
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_EXPORTTIME : // ora di esportazione
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_EXPORTRELEASE : // programma di esportazione
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_LANGUAGE : // lingua
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_RANGE : // range dei parametri
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_SCALEUNIT : // numero di decimali
{
Trim( sVal, " \t\r\n\"") ;
int nUnit ;
if ( FromString( sVal, nUnit)) {
m_dScale = pow( 10, - nUnit) ;
++ nRead ;
}
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
}
break ;
case KEY_GENE_PROCESSINGQUALITY : // qualità di lavorazione
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_COMPUTERNAME : // nome computer
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_USER : // nome utente
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_SOURCEFILE : // file sorgente
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_EXPORTFILE : // file di esportazione
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_RECESS : // finitura angoli interni
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
break ;
case KEY_GENE_USERATTRIBUTE : // attributo utente
m_BtlGeom.SetUserAttribute( UATD_INFO, sVal) ;
break ;
}
}
return false ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadRawPart( bool& bEnd)
{
string sLine ;
// leggo la prossima linea e verifico sia la sezione RAWPART
if ( ! m_theScanner.GetLine( sLine)) {
bEnd = true ;
return true ;
}
// verifico sia la sezione RAWPART
if ( sLine != SEC_RAWPART) {
m_theScanner.UngetLine( sLine) ;
bEnd = true ;
return true ;
}
// ciclo sulle linee
while ( m_theScanner.GetLine( sLine)) {
// se cambio sezione
if ( sLine[0] == '[') {
m_theScanner.UngetLine( sLine) ;
bEnd = false ;
return true ;
}
// ignoro tutto
}
bEnd = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadPart( bool& bEnd)
{
string sLine ;
// leggo la prossima linea
if ( ! m_theScanner.GetLine( sLine)) {
bEnd = true ;
return true ;
}
// verifico sia la sezione PART
if ( sLine != SEC_PART) {
m_theScanner.UngetLine( sLine) ;
bEnd = true ;
return true ;
}
// creo il pezzo
if ( ! m_BtlGeom.CreatePart()) {
string sOut = " Error (CreatePart) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
SkipCurrSection() ;
bEnd = false ;
return false ;
}
// ciclo sulle linee con i dati generali del pezzo
double dLength = 0, dHeight = 0, dWidth = 0 ;
bool bLength = false, bHeight = false, bWidth = false, bBox = false ;
int nUID = 0 ;
while ( m_theScanner.GetLine( sLine)) {
// se cambio sezione
if ( sLine[0] == '[') {
m_theScanner.UngetLine( sLine) ;
bEnd = false ;
// aggiorno outline
return m_BtlGeom.UpdateOutLine() ;
}
// spezzo la linea
string sKey, sVal ;
SplitFirst( sLine, ":", sKey, sVal) ;
switch ( FindPartKey( sKey)) {
case KEY_PART_SINGLEMEMBERNUMBER : // identificativo di produzione
{
int nProdNbr = 0 ;
if ( FromString( sVal, nProdNbr))
m_BtlGeom.SetPartProdNbr( nProdNbr) ;
}
break ;
case KEY_PART_ASSEMBLYNUMBER : // numero di lista nell'assemblato
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_ORDERNUMBER : // numero di lista nell'ordine
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_DESIGNATION : // nome
Trim( sVal, " \t\r\n\"") ;
if ( ! IsTextUtf8( sVal.c_str()))
sVal = LPSTR( WtoA( LPWSTR( AtoW( sVal.c_str(), 1252)))) ;
m_BtlGeom.SetPartName( sVal) ;
break ;
case KEY_PART_ANNOTATION : // annotazione
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_STOREY : // sottogruppo
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_GROUP : // gruppo
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_PACKAGE : // pacco di spedizione
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_MATERIAL : // materiale
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_TIMBERGRADE : // qualità legname
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_QUALITYGRADE : // qualità
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_COUNT : // quantità
{
int nCount = 0 ;
if ( FromString( sVal, nCount))
m_BtlGeom.SetPartCount( nCount) ;
}
break ;
case KEY_PART_LENGTH : // lunghezza (dimensione in X)
if ( FromString( sVal, dLength)) {
dLength *= m_dScale ;
bLength = true ;
}
if ( bLength && bHeight && bWidth) {
if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
bBox = true ;
}
break ;
case KEY_PART_HEIGHT : // altezza (dimensione in Y)
if ( FromString( sVal, dHeight)) {
dHeight *= m_dScale ;
bHeight = true ;
}
if ( bLength && bHeight && bWidth) {
if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
bBox = true ;
}
break ;
case KEY_PART_WIDTH : // larghezza (dimensione in Z)
if ( FromString( sVal, dWidth)) {
dWidth *= m_dScale ;
bWidth = true ;
}
if ( bLength && bHeight && bWidth) {
if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
bBox = true ;
}
break ;
case KEY_PART_COLOUR : // colore
{
Trim( sVal, " \t\r\n\"") ;
Color colRes ;
if ( ReadColor( sVal, colRes))
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( colRes)) ;
}
break ;
case KEY_PART_PLANINGLENGTH : // lunghezza spianatura
{
Trim( sVal, " \t\r\n\"") ;
double dVal ;
if ( GetParam( sVal, dVal))
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ;
}
break ;
case KEY_PART_STARTOFFSET : // offset iniziale
{
Trim( sVal, " \t\r\n\"") ;
double dVal ;
if ( GetParam( sVal, dVal))
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ;
}
break ;
case KEY_PART_ENDOFFSET : // offset finale
{
Trim( sVal, " \t\r\n\"") ;
double dVal ;
if ( GetParam( sVal, dVal))
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ;
}
break ;
case KEY_PART_UID : // UID istanza pezzo nella struttura
FromString( sVal, nUID) ;
break ;
case KEY_PART_TRANSFORMATION : // matrice di trasformazione istanza pezzo nella struttura
{
Frame3d frRef ;
if ( ReadTransformation( sVal, frRef))
m_BtlGeom.AddPartTransformation( nUID, frRef) ;
}
break ;
case KEY_PART_CAMBER : // incurvamento
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_PARTOFFSET : // offset pezzo
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_PROCESSINGQUALITY : // qualità di lavorazione
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_OUTLINE : // contorno
// interpreto l'outline
m_theScanner.UngetLine( sLine) ;
if ( ! ReadOutline()) {
string sOut = " Error (ReadOutline) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
SkipCurrSection() ;
m_BtlGeom.ErasePart() ;
bEnd = false ;
return false ;
}
break ;
case KEY_PART_APERTURE : // apertura
// interpreto l'apertura
m_theScanner.UngetLine( sLine) ;
if ( ! ReadAperture()) {
string sOut = " Error (ReadAperture) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
SkipCurrSection() ;
m_BtlGeom.ErasePart() ;
bEnd = false ;
return false ;
}
break ;
case KEY_PART_RECESS : // finitura angoli interni
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_STOREYTYPE : // tipo di piano
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_ELEMENTNUMBER : // numero elemento
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_LAYER : // layer
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_MODULENUMBER : // numero modulo
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_USERATTRIBUTE : // attributo utente
m_BtlGeom.SetUserAttribute( UATD_PART, sVal) ;
break ;
case KEY_PART_GRAINDIRECTION : // direzione venatura
{
Trim( sVal, " \t\r\n\"") ;
Vector3d vtDir ;
bool bAlign ;
if ( ReadGrainDirection( sVal, vtDir, bAlign))
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( vtDir) + ";" + ( bAlign ? "1" : "0")) ;
}
break ;
case KEY_PART_REFERENCESIDE : // lato di riferimento
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_ALIGNMENT : // allineamento
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
case KEY_PART_MATERIALTYPE : // tipo di materiale
Trim( sVal, " \t\r\n\"") ;
m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
break ;
}
// se lavorazione, esco dal ciclo
if ( sKey == sProcKey[KEY_PROC_PROCESSKEY]) {
m_theScanner.UngetLine( sLine) ;
break ;
}
}
// verifico sia stato definito il contorno del pezzo
if ( ! bBox) {
string sOut = " Error (AddPartBox) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
SkipCurrSection() ;
m_BtlGeom.ErasePart() ;
bEnd = false ;
return false ;
}
// interpreto le lavorazioni (processing)
bool bOk = true ;
for ( bool bProcEnd = false ; ! bProcEnd ;) {
if ( ! ReadProcess( bProcEnd)) {
// i log di errore sono già gestiti nella funzione chiamata
bOk = false ;
}
}
// inserisco eventuali contorni liberi
if ( ! m_BtlGeom.CreateFreeContours())
bOk = false ;
// aggiorno outline
if ( ! m_BtlGeom.UpdateOutLine()) {
string sOut = " Error (UpdateOutLine) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
m_BtlGeom.ErasePart() ;
}
bEnd = false ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadComposite( bool& bEnd)
{
string sLine ;
// leggo la prossima linea
if ( ! m_theScanner.GetLine( sLine)) {
bEnd = true ;
return true ;
}
// verifico sia la sezione COMPOSITE
if ( sLine != SEC_COMPOSITE) {
bEnd = true ;
return true ;
}
// ciclo sulle linee
while ( m_theScanner.GetLine( sLine)) {
// se cambio sezione
if ( sLine[0] == '[') {
m_theScanner.UngetLine( sLine) ;
bEnd = false ;
return true ;
}
// ignoro tutto
}
bEnd = true ;
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadTransformation( const string& sVal, Frame3d& frRef)
{
// leggo i valori
Point3d ptO ;
GetParam( sVal, PAR_OX, ptO.x) ;
GetParam( sVal, PAR_OY, ptO.y) ;
GetParam( sVal, PAR_OZ, ptO.z) ;
Vector3d vtX ;
GetParam( sVal, PAR_XX, vtX.x) ;
GetParam( sVal, PAR_XY, vtX.y) ;
GetParam( sVal, PAR_XZ, vtX.z) ;
Vector3d vtY ;
GetParam( sVal, PAR_YX, vtY.x) ;
GetParam( sVal, PAR_YY, vtY.y) ;
GetParam( sVal, PAR_YZ, vtY.z) ;
// calcolo il riferimento
return frRef.Set( ptO, ptO + vtX, ptO + vtY) ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadOutline( void)
{
bool bProcFound = false ;
int nSide = BTL_SIDE_NONE ;
FCEDEQUE dqFce ;
STRVECTOR vsUAtt ;
// ciclo sulle linee
string sLine ;
while ( m_theScanner.GetLine( sLine)) {
// spezzo la linea
string sKey, sVal ;
SplitFirst( sLine, ":", sKey, sVal) ;
// se attributo utente
if ( sKey == sPartKey[KEY_PART_USERATTRIBUTE]) {
vsUAtt.emplace_back( sVal) ;
continue ;
}
// se cambio tipologia, concludo
else if ( sKey != sPartKey[KEY_PART_OUTLINE]) {
m_theScanner.UngetLine( sLine) ;
break ;
}
// leggo i dati
// tipo
int nFlag ;
GetParamP( sVal, 8, nFlag) ;
// se non ancora assegnato, leggo se da lavorare
if ( ! bProcFound) {
string sToDo ;
if ( GetInfo( sVal, PAR_PROCESS, sToDo)) {
if ( sToDo.find( "YES") != 0)
vsUAtt.emplace_back( "DO:0") ;
bProcFound = true ;
}
}
// se non ancora assegnata, leggo faccia di riferimento
if ( nSide == BTL_SIDE_NONE)
GetInfo( sVal, PAR_SIDE, nSide) ;
// punto principale
Point3d ptP ;
GetParamP( sVal, 1, ptP.x) ;
GetParamP( sVal, 2, ptP.y) ;
GetParamP( sVal, 3, ptP.z) ;
// se arco leggo il punto intermedio
Point3d ptM ;
if ( nFlag == FreeContourEnt::ARC) {
GetParamP( sVal, 10, ptM.x) ;
GetParamP( sVal, 11, ptM.y) ;
GetParamP( sVal, 12, ptM.z) ;
}
// angolo di fianco
double dAng = ( nFlag == FreeContourEnt::START ? FC_SIDEANG_DEF : FC_SIDEANG_NONE) ;
GetParamP( sVal, 6, dAng) ;
// aggiungo i dati alla deque
dqFce.emplace_back( nFlag, ptP, ptM, dAng, 0, 0) ;
}
// inserimento del contorno nel pezzo
return m_BtlGeom.AddPartOutline( nSide, dqFce, vsUAtt) ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadAperture( void)
{
bool bProcFound = false ;
int nSide = BTL_SIDE_NONE ;
FCEDEQUE dqFce ;
STRVECTOR vsUAtt ;
// ciclo sulle linee
string sLine ;
while ( m_theScanner.GetLine( sLine)) {
// spezzo la linea
string sKey, sVal ;
SplitFirst( sLine, ":", sKey, sVal) ;
// se attributo utente
if ( sKey == sPartKey[KEY_PART_USERATTRIBUTE]) {
vsUAtt.emplace_back( sVal) ;
continue ;
}
// se cambio tipologia, concludo
else if ( sKey != sPartKey[KEY_PART_APERTURE]) {
m_theScanner.UngetLine( sLine) ;
break ;
}
// leggo i dati
// tipo
int nFlag ;
GetParamP( sVal, 8, nFlag) ;
// se tipo start ed esistono precedenti entità, ne derivo una apertura
if ( nFlag == FreeContourEnt::START && dqFce.size() > 0) {
if ( ! m_BtlGeom.AddPartAperture( nSide, dqFce, vsUAtt))
return false ;
nSide = BTL_SIDE_NONE ;
bProcFound = false ;
dqFce.clear() ;
vsUAtt.clear() ;
}
// se non ancora assegnato, leggo se da lavorare
if ( ! bProcFound) {
string sToDo ;
if ( GetInfo( sVal, PAR_PROCESS, sToDo)) {
if ( sToDo.find( "YES") != 0)
vsUAtt.emplace_back( "DO:0") ;
bProcFound = true ;
}
}
// se non ancora assegnata, leggo faccia di riferimento
if ( nSide == BTL_SIDE_NONE)
GetInfo( sVal, PAR_SIDE, nSide) ;
// punto principale
Point3d ptP ;
GetParamP( sVal, 1, ptP.x) ;
GetParamP( sVal, 2, ptP.y) ;
GetParamP( sVal, 3, ptP.z) ;
// se arco leggo il punto intermedio
Point3d ptM ;
if ( nFlag == FreeContourEnt::ARC) {
GetParamP( sVal, 10, ptM.x) ;
GetParamP( sVal, 11, ptM.y) ;
GetParamP( sVal, 12, ptM.z) ;
}
// angolo di fianco
double dAng = ( nFlag == FreeContourEnt::START ? FC_SIDEANG_DEF : FC_SIDEANG_NONE) ;
GetParamP( sVal, 6, dAng) ;
// aggiungo i dati alla deque
dqFce.emplace_back( nFlag, ptP, ptM, dAng, 0, 0) ;
}
// inserimento dell'ultima apertura nel pezzo
return m_BtlGeom.AddPartAperture( nSide, dqFce, vsUAtt) ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadColor( const string& sVal, Color& colRes)
{
// leggo i valori
string sRes ;
GetParam( sVal, PAR_R, sRes) ;
int nRed ; FromString( sRes, nRed) ;
GetParam( sVal, PAR_G, sRes) ;
int nGreen ; FromString( sRes, nGreen) ;
GetParam( sVal, PAR_B, sRes) ;
int nBlue ; FromString( sRes, nBlue) ;
GetParam( sVal, PAR_A, sRes) ;
int nAlpha ; FromString( sRes, nAlpha) ; nAlpha = nAlpha * 100 / 255 ;
colRes.Set( nRed, nGreen, nBlue, nAlpha) ;
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadGrainDirection( const string& sVal, Vector3d& vtDir, bool& bAlign)
{
// leggo i valori
GetParam( sVal, PAR_X, vtDir.x) ;
GetParam( sVal, PAR_Y, vtDir.y) ;
GetParam( sVal, PAR_Z, vtDir.z) ;
string sRes ;
GetParam( sVal, PAR_ALIGN, sRes) ;
bAlign = ( sRes == "YES") ;
// ritorno
return ( vtDir.Normalize()) ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::ReadProcess( bool& bProcEnd)
{
bProcEnd = false ;
string sLine ;
// leggo la prossima linea
if ( ! m_theScanner.GetLine( sLine)) {
bProcEnd = true ;
return true ;
}
// verifico sia l'istruzione PROCESSKEY
if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) == string::npos) {
m_theScanner.UngetLine( sLine) ;
bProcEnd = true ;
return true ;
}
// recupero i parametri
string sKey, sVal ;
SplitFirst( sLine, ":", sKey, sVal) ;
TrimLeft( sVal) ;
string sType, sDes ;
SplitFirst( sVal, " ", sType, sDes) ;
Trim( sDes) ;
STRVECTOR vsItem ;
Tokenize( sType, "-", vsItem) ;
if ( vsItem.size() < 3) {
string sOut = " Error in ProcessType(" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
SkipCurrProcess() ;
bProcEnd = false ;
return false ;
}
int nGroup = 0 ;
FromString( vsItem[0], nGroup) ;
int nProc = 0 ;
FromString( vsItem[1], nProc) ;
int nSide = 0 ;
FromString( vsItem[2], nSide) ;
if ( nSide < BTL_SIDE_FRONT || nSide > BTL_SIDE_TOP)
nSide = BTL_SIDE_FRONT ;
bool bParams = false ;
INTVECTOR vnDPar ;
int nSPar ;
DBLVECTOR vdPar ;
string sPar ;
int nProcId = 0 ;
Frame3d frRef ;
STRVECTOR vsUAtt ;
// ciclo sulle linee
while ( true) {
// se fine file, concludo
if ( ! m_theScanner.GetLine( sLine)) {
bProcEnd = true ;
break ;
}
// se cambio sezione, concludo
if ( sLine[0] == '[') {
m_theScanner.UngetLine( sLine) ;
bProcEnd = true ;
break ;
}
// se nuova lavorazione, concludo
if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) != string::npos) {
m_theScanner.UngetLine( sLine) ;
bProcEnd = false ;
break ;
}
// spezzo la linea
string sKey, sVal ;
SplitFirst( sLine, ":", sKey, sVal) ;
switch ( FindProcessKey( sKey)) {
case KEY_PROC_REFERENCEPLANE : // riferimento
if ( ! ReadTransformation( sVal, frRef)) {
string sOut = " Error : unable to read ReferencePlane (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
SkipCurrProcess() ;
bProcEnd = false ;
return false ;
}
break ;
case KEY_PROC_PROCESSPARAMETERS : // parametri
if ( ! m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar)) {
string sOut = " Error : Unknown Process (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
SkipCurrProcess() ;
bProcEnd = false ;
return true ;
}
else if ( ! GetProcessParams( sVal, sType, vnDPar, nSPar, vdPar, sPar)) {
string sOut = " Error in GetProcessParams (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
SkipCurrProcess() ;
bProcEnd = false ;
return false ;
}
bParams = true ;
break ;
case KEY_PROC_PROCESSIDENT : // identificativo
FromString( sVal, nProcId) ;
break ;
case KEY_PROC_PROCESSINGQUALITY : // qualità di lavorazione
Trim( sVal, " \t\r\n\"") ;
vsUAtt.emplace_back( sKey + ":" + sVal) ;
break ;
case KEY_PROC_USERATTRIBUTE : // attributo utente
vsUAtt.emplace_back( sVal) ;
break ;
case KEY_PROC_PRIORITY : // priorità di lavorazione
Trim( sVal, " \t\r\n\"") ;
vsUAtt.emplace_back( sKey + ":" + sVal) ;
break ;
case KEY_PROC_RECESS : // tipo angolo interno
Trim( sVal, " \t\r\n\"") ;
vsUAtt.emplace_back( sKey + ":" + sVal) ;
break ;
case KEY_PROC_PROCESS : // indicazione di produzione
Trim( sVal) ;
if ( sVal != "YES")
vsUAtt.emplace_back( "DO:0") ;
break ;
}
}
// inserimento della lavorazione nel pezzo
if ( ! bParams ||
! m_BtlGeom.AddProcess( nGroup, nProc, nSide, sDes, nProcId, frRef, vnDPar, nSPar, vdPar, sPar, vsUAtt, m_theScanner.GetCurrLineNbr())) {
string sOut = " Error in AddProcess (" + sType + ") to Part " + m_BtlGeom.GetPartName() + " on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_ERROR( GetEExLogger(), sOut.c_str())
bProcEnd = false ;
return false ;
}
bProcEnd = false ;
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::SkipCurrSection( void)
{
// ciclo sulle linee
string sLine ;
while ( true) {
// se fine file, concludo
if ( ! m_theScanner.GetLine( sLine)) {
break ;
}
// se cambio sezione, concludo
if ( sLine[0] == '[') {
m_theScanner.UngetLine( sLine) ;
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::SkipCurrProcess( void)
{
// ciclo sulle linee
string sLine ;
while ( true) {
// se fine file, concludo
if ( ! m_theScanner.GetLine( sLine)) {
break ;
}
// se cambio sezione, concludo
if ( sLine[0] == '[') {
m_theScanner.UngetLine( sLine) ;
break ;
}
// se nuova lavorazione, concludo
if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) != string::npos) {
m_theScanner.UngetLine( sLine) ;
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetProcessParams( const string& sText, const string& sProcType,
const INTVECTOR& vnDPar, int nSPar,
DBLVECTOR& vdPar, string& sPar)
{
// verifico corrispondenza numero definizioni - numero parametri numerici
if ( vnDPar.size() != vdPar.size())
return false ;
// leggo i parametri numerici
for ( int i = 0 ; i < int( vnDPar.size()) ; ++ i) {
if ( ! GetParamP( sText, vnDPar[i], vdPar[i])) {
string sOut = " Info : P" + ToString( vnDPar[i], 2) + " missing in Process (" + sProcType +
") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_DBG_INFO( GetEExLogger(), sOut.c_str())
}
}
// leggo l'eventuale parametro stringa
if ( nSPar != 0) {
if ( ! GetParamP( sText, nSPar, sPar)) {
string sOut = " Info : P" + ToString( nSPar, 2) + " missing in Process (" + sProcType +
") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
LOG_DBG_INFO( GetEExLogger(), sOut.c_str())
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetInfo( const string& sText, const string& sPar, string& sVal)
{
// cerco l'identificativo del parametro
size_t nPos = sText.find( sPar + ":") ;
if ( nPos == string::npos)
return false ;
// recupero la stringa successiva
const int SVAL_LEN = 6 ;
sVal = sText.substr( nPos + sPar.length() + 1, SVAL_LEN) ;
Trim( sVal, " \t\r\n0") ;
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetInfo( const string& sText, const string& sPar, int& nVal)
{
string sVal ;
if ( ! GetInfo( sText, sPar, sVal))
return false ;
nVal = 0 ;
FromString( sVal, nVal) ;
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetParam( const string& sPar, double& dVal)
{
string sVal = sPar ;
TrimLeft( sVal, " \t\r\n0") ;
dVal = 0 ;
FromString( sVal, dVal) ;
dVal *= m_dScale ;
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetParam( const string& sText, const string& sPar, double& dVal)
{
// cerco l'identificativo del parametro
size_t nPos = sText.find( sPar + ":") ;
if ( nPos == string::npos)
return false ;
// recupero la stringa successiva
const int SVAL_LEN = 14 ;
string sVal = sText.substr( nPos + sPar.length() + 1, SVAL_LEN) ;
TrimLeft( sVal, " \t\r\n0") ;
dVal = 0 ;
FromString( sVal, dVal) ;
dVal *= m_dScale ;
return true ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetParam( const string& sText, const string& sPar, string& sVal)
{
// cerco l'identificativo del parametro
size_t nPos = sText.find( sPar + ":") ;
if ( nPos == string::npos)
return false ;
// cerco i delimitatori della stringa "
size_t nPosI = sText.find( "\"", nPos + sPar.length() + 1) ;
size_t nPosF = sText.find( "\"", nPosI + 1) ;
if ( nPosI != string::npos && nPosF != string::npos) {
sVal = sText.substr( nPosI + 1, nPosF - nPosI - 1) ;
return true ;
}
else {
sVal = sText.substr( nPos + sPar.length() + 1) ;
Trim( sVal, " \t\r\n\"") ;
return true ;
}
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetParamP( const string& sText, int nInd, int& nVal)
{
// creo l'identificativo
string sPar = PAR_P + ToString( nInd, 2) ;
// leggo il parametro
double dVal ;
bool bOk = GetParam( sText, sPar, dVal) ;
nVal = lround( dVal) ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetParamP( const string& sText, int nInd, double& dVal)
{
// creo l'identificativo
string sPar = PAR_P + ToString( nInd, 2) ;
// leggo il parametro
return GetParam( sText, sPar, dVal) ;
}
//----------------------------------------------------------------------------
bool
ImportBtl::GetParamP( const string& sText, int nInd, string& sVal)
{
// creo l'identificativo
string sPar = PAR_P + ToString( nInd, 2) ;
// leggo il parametro
return GetParam( sText, sPar, sVal) ;
}
Reference in New Issue View Git Blame Copy Permalink