Dario Sassi
6bbdf97993
- adattamenti per modifica nomi include di base - allineate Set/GetInfo di GdbIterator a quelle di GeomDB - aggiunte Set/GetInfo per STRVECTOR.
395 lines
11 KiB
C++
395 lines
11 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2014-2014
|
|
//----------------------------------------------------------------------------
|
|
// File : NgeReader.cpp Data : 14.04.14 Versione : 1.5d5
|
|
// Contenuto : Implementazione della classe NgeReader.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 14.04.14 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "NgeReader.h"
|
|
#include "NgeKeyW.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
#include "/EgtDev/Include/EgtStringConverter.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::Init( const std::string& sFileIn)
|
|
{
|
|
switch ( NgeType( sFileIn)) {
|
|
case NGE_ASCII :
|
|
m_bBinary = false ;
|
|
m_iPosStart = string::npos ;
|
|
m_sLine.reserve( 128) ;
|
|
m_sToken.reserve( 48) ;
|
|
return m_Scan.Init( sFileIn) ;
|
|
break ;
|
|
case NGE_BINARY :
|
|
m_bBinary = true ;
|
|
m_InFile.open( stringtoW( sFileIn), ios::in | ios::binary, _SH_DENYWR) ;
|
|
return ( ! m_InFile.fail()) ;
|
|
break ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::Close( void)
|
|
{
|
|
if ( m_bBinary) {
|
|
bool bOk = ( m_InFile.good() && m_InFile.is_open()) ;
|
|
if ( m_InFile.is_open())
|
|
m_InFile.close() ;
|
|
return bOk ;
|
|
}
|
|
else
|
|
return m_Scan.Terminate() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
NgeReader::NgeType( const std::string& sFile)
|
|
{
|
|
// apertura del file di ingresso
|
|
ifstream InFile ;
|
|
InFile.open( stringtoW( sFile), ios::in | ios::binary) ;
|
|
if ( InFile.fail())
|
|
return NGE_ERROR ;
|
|
|
|
// lettura dei primi 31 byte
|
|
char cBuff[32] ;
|
|
InFile.read( cBuff, 31) ;
|
|
cBuff[InFile.gcount()] = '\0' ;
|
|
|
|
// chiusura del file
|
|
InFile.close() ;
|
|
|
|
// verifico se file compresso (gz)
|
|
if ( cBuff[0] == '\x1F' && cBuff[1] == '\x8B')
|
|
return NGE_ASCII ;
|
|
|
|
// verifico se iniziano con "START"
|
|
string sBuff = cBuff ;
|
|
size_t nPos = sBuff.find( "START") ;
|
|
if ( nPos != string::npos && nPos < 10)
|
|
return NGE_ASCII ;
|
|
else
|
|
return NGE_BINARY ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
NgeReader::GetCurrPos( void)
|
|
{
|
|
if ( m_bBinary)
|
|
return int( m_InFile.tellg()) ;
|
|
else
|
|
return m_Scan.GetCurrLineNbr() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::GetToken( std::string& sToken, const char* szSep, bool bEndL)
|
|
{
|
|
// se necessario, lettura nuova linea
|
|
if ( m_iPosStart == string::npos) {
|
|
if ( ! m_Scan.GetLine( m_sLine))
|
|
return false ;
|
|
m_iPosStart = 0 ;
|
|
}
|
|
// se richiesta ricerca separatore
|
|
if ( szSep != nullptr) {
|
|
// cerco il primo separatore nella linea
|
|
string::size_type iPosEnd = m_sLine.find_first_of( szSep, m_iPosStart) ;
|
|
sToken = m_sLine.substr( m_iPosStart, iPosEnd - m_iPosStart) ;
|
|
// passo al prossimo
|
|
m_iPosStart = m_sLine.find_first_not_of( szSep, iPosEnd) ;
|
|
if ( bEndL)
|
|
return ( m_iPosStart == string::npos) ;
|
|
else
|
|
return ( m_iPosStart != string::npos) ;
|
|
}
|
|
// altrimenti, deve essere tutto con endl obbligatorio
|
|
else {
|
|
sToken = m_sLine.substr( m_iPosStart, string::npos) ;
|
|
m_iPosStart = string::npos ;
|
|
return bEndL ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadUchar( unsigned char& ucVal, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
m_InFile.read( (char*) &ucVal, sizeof( ucVal)) ;
|
|
return m_InFile.good() ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
int nVal ;
|
|
if ( ! FromString( m_sToken, nVal))
|
|
return false ;
|
|
ucVal = nVal ;
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadBool( bool& bVal, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
m_InFile.read( (char*) &bVal, sizeof( bVal)) ;
|
|
return m_InFile.good() ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
return FromString( m_sToken, bVal) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadInt( int& nVal, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
m_InFile.read( (char*) &nVal, sizeof( nVal)) ;
|
|
return m_InFile.good() ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
return FromString( m_sToken, nVal) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadDouble( double& dVal, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
m_InFile.read( (char*) &dVal, sizeof( dVal)) ;
|
|
return m_InFile.good() ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
return FromString( m_sToken, dVal) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadVector( Vector3d& vtV, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
m_InFile.read( (char*) &vtV.v, sizeof( vtV.v)) ;
|
|
return m_InFile.good() ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
return FromString( m_sToken, vtV) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadPoint( Point3d& ptP, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
m_InFile.read( (char*) &ptP.v, sizeof( ptP.v)) ;
|
|
return m_InFile.good() ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
return FromString( m_sToken, ptP) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadPointW( Point3d& ptP, double& dW, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
m_InFile.read( (char*) &ptP.v, sizeof( ptP.v)) ;
|
|
m_InFile.read( (char*) &dW, sizeof( dW)) ;
|
|
return m_InFile.good() ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
return FromString( m_sToken, ptP, dW) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadFrame( Frame3d& frF, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
Point3d ptOrig ;
|
|
m_InFile.read( (char*) &ptOrig.v, sizeof( ptOrig.v)) ;
|
|
Vector3d vtDirX ;
|
|
m_InFile.read( (char*) &vtDirX.v, sizeof( vtDirX.v)) ;
|
|
Vector3d vtDirY ;
|
|
m_InFile.read( (char*) &vtDirY.v, sizeof( vtDirY.v)) ;
|
|
Vector3d vtDirZ ;
|
|
m_InFile.read( (char*) &vtDirZ.v, sizeof( vtDirZ.v)) ;
|
|
if ( ! m_InFile.good())
|
|
return false ;
|
|
return frF.Set( ptOrig, vtDirX, vtDirY, vtDirZ) ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
return FromString( m_sToken, frF) ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadString( string& sVal, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
const int MAX_STR_DIM = 65535 ;
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
int nDim ;
|
|
m_InFile.read( (char*) &nDim, sizeof( nDim)) ;
|
|
if ( nDim > MAX_STR_DIM || ! m_InFile.good())
|
|
return false ;
|
|
char* szBuff = new char[ nDim + 1] ;
|
|
if ( szBuff == nullptr)
|
|
return false ;
|
|
m_InFile.read( szBuff, nDim) ;
|
|
if ( ! m_InFile.good()) {
|
|
delete szBuff ;
|
|
return false ;
|
|
}
|
|
szBuff[nDim] = '\0' ;
|
|
sVal = szBuff ;
|
|
delete szBuff ;
|
|
return true ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// lo copio nella stringa
|
|
sVal = m_sToken ;
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadKey( int& nKey)
|
|
{
|
|
if ( m_bUngetKey) {
|
|
m_bUngetKey = false ;
|
|
nKey = m_nLastKey ;
|
|
return true ;
|
|
}
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
// leggo il dato
|
|
int nVal ;
|
|
m_InFile.read( (char*) &nVal, sizeof( nVal)) ;
|
|
if ( ! m_InFile.good())
|
|
return false ;
|
|
// ricavo l'indice
|
|
for ( int i = 0 ; i <= NGE_LAST_ID ; ++ i) {
|
|
if ( nVal == NgeBinKeyW[i]) {
|
|
nKey = i ;
|
|
m_nLastKey = nKey ;
|
|
return true ;
|
|
}
|
|
}
|
|
return false ;
|
|
}
|
|
else {
|
|
// recupero la linea
|
|
if ( ! GetToken( m_sToken, nullptr, true))
|
|
return false ;
|
|
// ricavo l'indice
|
|
for ( int i = 0 ; i <= NGE_LAST_ID ; ++ i) {
|
|
if ( m_sToken == NgeAscKeyW[i]) {
|
|
nKey = i ;
|
|
m_nLastKey = nKey ;
|
|
return true ;
|
|
}
|
|
}
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
NgeReader::ReadCol( Color& cCol, const char* szSep, bool bEndL)
|
|
{
|
|
if ( m_bBinary) {
|
|
if ( ! m_InFile.is_open())
|
|
return false ;
|
|
unsigned char ucCol[4] ;
|
|
m_InFile.read( (char*) &ucCol, sizeof( ucCol)) ;
|
|
if ( ! m_InFile.good())
|
|
return false ;
|
|
cCol.Set( ucCol[0], ucCol[1], ucCol[2], ucCol[3]) ;
|
|
return true ;
|
|
}
|
|
else {
|
|
// recupero il token
|
|
if ( ! GetToken( m_sToken, szSep, bEndL))
|
|
return false ;
|
|
// ricavo il valore
|
|
return FromString( m_sToken, cCol) ;
|
|
}
|
|
}
|