iofun.cpp

/*********************************************************************/ 
/*                                                                   */ 
/*             Config files library - (C) TGG 2015                   */ 
/*                                                                   */ 
/*********************************************************************/ 
/*                          Warszawa, 2015                           */ 
/*********************************************************************/ 
/*                                                                   */
/* File: iofun.cpp                                                   */
/*                                                                   */
/* Author: T.Grabowski                                               */
/*                                                                   */
/* Contents - simple I/O functions class                             */
/*                                                                   */ 
/*                                                                   */
/*********************************************************************/
/*                                                                   */
/*                                                                   */
 
#include "iofun.h"
 
 
// CONVERT WINDOWS BACKSLASHES TO UNIX FRONTSLASHES
 
void IOFUN::Win2Unix(char *s) 
{
  for ( ; *s; s++ )
    if ( *s == '\\' ) *s = '/';
}
 
// CONVERT UNIX FRONTSLASHES TO WINDOWS BACKSLASHES
 
void IOFUN::Unix2Win(char *s) 
{
  for ( ; *s; s++ )
    if ( *s == '/' ) *s = '\\';
} 
 
 
/*--------------------------------------------------------------------*/
 
int IOFUN::ReadComm( FILE *stream )
{
    char a;
    while ( a = fgetc( stream ) , ( a != '\n' && a != EOF && a != 0xD ) );      /* omit comment */
    if( a == EOF )return EOF;
    return 0;   
}
 
void IOFUN::ReadDummy( FILE *stream )
{
    unsigned char ucRes = 1;
    while ( ucRes )
        {
        char ch = fgetc(stream);
        ucRes = (ch == '#');
        ungetc(ch,stream);
        //fseek( stream, -1, SEEK_CUR );
        if( ucRes )ReadComm( stream );
        }
}
 
/*--------------------------------------------------------------------*/
 
//  read up to four values from one line with comment
 
int IOFUN::ReadPar( FILE *stream, const char *Format, void *Par )
{
    ReadDummy( stream );
    fscanf( stream, Format, Par );          /* read value    */
    return ReadComm( stream );
}
 
int IOFUN::ReadPar( FILE *stream, const char *Format, void *Par1, void *Par2 )
{
    ReadDummy( stream );
    fscanf( stream, Format, Par1, Par2 );
    return ReadComm( stream );
}
 
int IOFUN::ReadPar( FILE *stream, const char *Format, void *Par1, void *Par2, void *Par3 )
{
    ReadDummy( stream );
    fscanf( stream, Format, Par1, Par2, Par3 );
    return ReadComm( stream );
}
 
int IOFUN::ReadPar( FILE * stream, const char * Format, void *Par1, void *Par2, void *Par3, void *Par4 )
{
    ReadDummy( stream );
    fscanf( stream, Format, Par1, Par2, Par3, Par4 );
    return ReadComm( stream );
}
 
/*--------------------------------------------------------------------*/
 
//  read n-element vector from one line with comment
 
int IOFUN::ReadVect( FILE *stream, double *Par, int n, double dScal )
{
    ReadDummy( stream );
    int i, ierr = 0;
    for( i=0; i<n; i++ ) ierr = fscanf( stream, "%lf", Par+i ); /* read values    */
    if( ierr == -1 ) return -1;
    ReadComm( stream );
    for( i=0; i<n; i++ ) Par[i] *= dScal;
    return 0;
}
int IOFUN::ReadVect( FILE *stream, float *Par, int n, float fScal )
{
    ReadDummy( stream );
    int i, ierr = 0;
    for( i=0; i<n; i++ ) ierr = fscanf( stream, "%f", Par+i );
    if( ierr == -1 ) return -1;
    ReadComm( stream );
    for( i=0; i<n; i++ ) Par[i] *= fScal;
    return 0;
}
int IOFUN::ReadVect( FILE *stream, long *Par, int n, long lScal )
{
    ReadDummy( stream );
    int i, ierr = 0;
    for( i=0; i<n; i++ ) ierr = fscanf( stream, "%ld", Par+i );
    if( ierr == -1 ) return -1;
    ReadComm( stream );
    for( i=0; i<n; i++ ) Par[i] *= lScal;
    return 0;
}
int IOFUN::ReadVect( FILE *stream, int *Par, int n, int iScal )
{
    ReadDummy( stream );
    int i, ierr = 0;
    for( i=0; i<n; i++ ) ierr = fscanf( stream, "%d", Par+i );
    if( ierr == -1 ) return -1;
    ReadComm( stream );
    for( i=0; i<n; i++ ) Par[i] *= iScal;
    return 0;
}
/*--------------------------------------------------------------------*/
 
//  read 3-element vector from one line with comment
 
int IOFUN::ReadVect3( FILE *stream, double *Par, double dScal )
{
    return ReadVect( stream, Par, 3, dScal );
}
int IOFUN::ReadVect3( FILE *stream, float *Par, float fScal )
{
    return ReadVect( stream, Par, 3, fScal );
}
int IOFUN::ReadVect3( FILE *stream, long *Par, long lScal )
{
    return ReadVect( stream, Par, 3, lScal );
}
int IOFUN::ReadVect3( FILE *stream, int *Par, int iScal )
{
    return ReadVect( stream, Par, 3, iScal );
}
/*--------------------------------------------------------------------*/
 
//  read line
 
int IOFUN::ReadStr( FILE * stream, char *Par )
{
    ReadDummy( stream );
 
    char cc;
    int i;
    
    cc = fgetc( stream );
    i = 0;
    while ( cc != '\n' && cc != EOF && cc != 0xD ) 
        {
        Par[i] = cc;
        cc = fgetc( stream);
        i++;
        }
    if( cc == 0xD )
        {
        cc = fgetc( stream );
        if( cc != 0xA )ungetc( cc, stream );
        }
    
    Par[i]='\0';
 
    int j;
    for( j=i-1; j>0; j-- )
        {
        if( isblank(Par[j]) )
            Par[j] = '\0';
        else
            break;
        }
        
    char *cRob = new char[j+2];
    std::strcpy( cRob, Par );
    int i0 = 0;
    for( int i=0; i<j+1; i++ )
        {
        if( isblank(cRob[i]) )
            i0 = i+1;
        else
            break;
        }
    strcpy( Par, cRob+i0 );
    delete [] cRob;
    
    if( cc == EOF )return EOF;
    return strlen( Par );   
}
 
/*--------------------------------------------------------------------*/
 
//  read line with string length
 
void IOFUN::ReadStrL( FILE * stream, char *Par , int *len)
{
    char cc;
    int i;
    
    cc = fgetc( stream );
    i = 0;
    while ( cc != '\n' && cc != EOF && cc != 0xD ) 
        {
        Par[i] = cc;
        cc = fgetc( stream);
        i++;
        }
    if( cc == 0xD )
        {
        cc = fgetc( stream );
        if( cc != 0xA )ungetc(cc,stream);
        }
 
    Par[i]='\0';
    if( cc == EOF )Par[i+1]=EOF;
    *len = i;
        
}
 
/*--------------------------------------------------------------------*/
 
void IOFUN::ClipString( char* string )
{
    int i=0;
    while( !( isspace( string[i] ) || string[i] == '#' || string[i] == '\0' ) ) i++;
    string[i] = '\0';
}       
 
void IOFUN::ClipFileName( char* string )
{
    int len = strlen( string );
    int i=0;
    while( !( string[i] == '#' || string[i] == '\0' ) ) i++;
    i--;
    while( isspace( string[i] ) )i--;
    i++;
    string[i] = '\0';
    for( int ii=i; ii<len; ii++ )string[ii] = '\0';
    
#ifdef WIN32
    Unix2Win( string );
#else
    Win2Unix( string );
#endif
}       
 
/*--------------------------------------------------------------------*/
 
bool IOFUN::CompareStrings( char* str1, char* str2 )
{
    char tmp1[256], tmp2[256];
    int i;
    for( i=0; i<(int)strlen(str1); i++ ) tmp1[i] = tolower( str1[i] ); tmp1[i] = '\0';
    for( i=0; i<(int)strlen(str2); i++ ) tmp2[i] = tolower( str2[i] ); tmp2[i] = '\0';
    if( strcmp( tmp1, tmp2 ) == 0 )
        return true;
    else
        return false;
}
 
/*--------------------------------------------------------------------*/
 
const char* IOFUN::filename_name( const char *name ) 
{
    const char *p, *q;
    if (!name) return (0);
    for ( p = q = name ; *p ; ) 
    {
      if ( ( p[0] == ':' ) && ( p[1] == ':' ) ) 
      {
        q = p+2;
        p++;
      }
      else if (p[0] == '/' || p[0]=='\\' )
        q = p + 1;
      p++;
    }
    return q;
}
 
const char* IOFUN::filename_ext(const char *buf)
{
    const char *q = 0;
    const char *p = buf;
    for (p=buf; *p; p++) 
        {
        if (*p == '/') q = 0;
#ifdef WIN32
        else if (*p == '\\') q = 0;
#endif
        else if (*p == '.') q = p;
        }
    return q ? q : p;
}
 
char* IOFUN::filename_setext(char *buf, int buflen, const char *ext)
{
    char *q = (char *)filename_ext(buf);
    if (ext) 
        strlcpy(q,ext,buflen - (q - buf));
    else 
        *q = 0;
    return (buf);
}
 
int IOFUN::file_exist( const char *name )
{
    int iReturn = 0;
    FILE *fc = fopen( name, "r" );
    if( fc )
        {
        fclose( fc );
        iReturn = 1;
        }
 
    return iReturn;
}
 
int IOFUN::filename_dir( char *name )
{
    int ilen = strlen(name);
    if( ilen == 0 )return 0;
    int i = ilen-1;
    while( name[i] != '/' && name[i] != '\\' && name[i] != ':' && i >= 0 )
        i--;
    int id = i+1;
 
#ifdef WIN32
    Unix2Win( name );
#else
    Win2Unix( name );
#endif    
 
    return id;
}
 
FILE* IOFUN::fopen(const char*filename, const char*mode)
{
#ifdef _WIN32
    int fn_len_s = strlen(filename);
    int  m_len_s = strlen(mode);
    if( fn_len_s == 0 ) return NULL;
    if(  m_len_s == 0 ) return NULL;
    wchar_t path[MAX_PATH];
    wchar_t wmode[MAX_PATH];
    
    int new_Len_f = MultiByteToWideChar(CP_UTF8, 0, filename, fn_len_s, path, fn_len_s);
    if( new_Len_f >= MAX_PATH ) return NULL;
    path[new_Len_f] = L'\0';
    
    int new_Len_m = MultiByteToWideChar(CP_UTF8, 0, mode, m_len_s, wmode, m_len_s);
    if( new_Len_m >= MAX_PATH ) return NULL;
    wmode[new_Len_m] = L'\0';
    
    return _wfopen(path, wmode);
#else
    return ::fopen(filename, mode);
#endif
}
 
int IOFUN::stat(const char* f, struct stat *b)
{
#ifdef WIN32
    int fn_len_s = strlen(f);
    if( fn_len_s == 0 ) return 0;
    wchar_t path[MAX_PATH];
    
    int new_Len_f = MultiByteToWideChar(CP_UTF8, 0, f, fn_len_s, path, fn_len_s);
    if( new_Len_f >= MAX_PATH ) return 0;
    path[new_Len_f] = L'\0';
 
    return _wstat(path, (struct _stat*)b);
#else
    return ::stat(f, b);
#endif
}
 
const char* IOFUN::filename_date( const char *name ) 
{
    static char date[100];
    struct stat b;
    if( !stat( name, & b ) )
        {
        strftime( date, 100, "%d/%m/%Y %H:%M:%S", localtime( & b.st_mtime ) );
        return date;
        }
    else
        {
        fprintf( stderr, "filename_date Error\n" );
        return 0;
        }
}
 
size_t IOFUN::strlcpy(char *d, const char *s, size_t size)
{
    if (size <= 0) return 0;
    size_t len = strlen(s);
    size_t retVal = len;
    if (len >= size) len = size-1;
    memcpy(d, s, len);
    d[len] = '\0';
    return retVal;
}
 
int IOFUN::nLines( FILE * stream )
{
    long lPos = ftell( stream );
    
    char cc[512];
    long int i = 0;
    int iLen = 0;
    do
        {
        ReadStrL( stream, cc, &iLen );
        if( isstrblank( cc, iLen ) ) continue;
        i++;
        }
    while( iLen > 0 || cc[iLen+1] != EOF );
    //i--;
    
    fseek( stream, lPos, SEEK_SET );
 
    return i;       
}
 
int IOFUN::nColumns( FILE * stream, char Par[][32] )
{
    char cc , cc_old = ' ';
 
    cc = fgetc( stream );
    int i = 0;
    int licz = -1;
    while ( cc != '\n' && cc != EOF && cc != 0xD ) 
        {
        if( ( isblank(cc_old) && !isblank(cc) ) )
            {
            i = 0;
            licz++;
            Par[licz][i] = cc;
            i++;
            }
        else if( !isblank(cc) )
            {
            Par[licz][i] = cc;
            i++;
            }  
        cc_old = cc;
        cc = fgetc( stream);
        }
    if( cc == 0xD) cc = fgetc( stream);
 
    return licz+1;
}
 
int IOFUN::isstrblank( char *cc, int iLen )
{
    int iReturn = 1;
    if( iLen > 0 )
        {
        for( int i=0; i<iLen; i++ )
            {
            if( !isblank(cc[i]) )
                {
                iReturn  = 0;
                break;
                }
            }
        }
//  else
//      iReturn = 0;
        
    return iReturn;
}
 
void IOFUN::ReadVect3( FILE *stream, VECTOR_3D *Vec, double dScal )
{
    double Par[3];
    ReadVect3( stream, Par, dScal );
    Vec->GetFrom( Par );
}
 
//
//             Pascal style "readln" and "read" functions
//             by P.Blaszczyk - modif. by TGG (2002)
//
 
int IOFUN::readln( FILE *ff, char *value_x )
{
    fscanf( ff, "%s", value_x );
    return ReadComm( ff );
    //return 0;
}
 
int IOFUN::readln( FILE *ff, int *value_x )
{
    ReadPar( ff, "%d", value_x );
    return 0;
}
 
int IOFUN::readln( FILE *ff, long *value_x )
{
    ReadPar( ff, "%ld", value_x );
    return 0;
}
 
int IOFUN::readln( FILE *ff, float *value_x )
{
    ReadPar( ff, "%f", value_x );
    return 0;
}
 
int IOFUN::readln( FILE *ff, double *value_x )
{
    ReadPar( ff, "%lf", value_x );
    return 0;
}
 
int IOFUN::readln( FILE *ff, long double *value_x )
{
    ReadPar( ff, "%Lf", value_x );
    return 0;
}
 
int IOFUN::readln( FILE *ff )
{
    ReadComm( ff );
    return 0;
}
 
int IOFUN::readln( FILE *ff, VECTOR_3D *vec )
{
    ReadVect3( ff, vec );
    return 0;
}
 
// "read" function
 
int IOFUN::read( FILE *ff, char *value_x )
{
    fscanf( ff, "%s", value_x );
    return 0;
}
 
int IOFUN::read( FILE *ff, int *value_x )
{
    fscanf( ff, "%d", value_x );
    return 0;
}
 
int IOFUN::read( FILE *ff, long *value_x )
{
    fscanf( ff, "%ld", value_x );
    return 0;
}
 
int IOFUN::read( FILE *ff, float *value_x )
{
    fscanf( ff, "%f", value_x );
    return 0;
}
 
int IOFUN::read( FILE *ff, double *value_x )
{
    fscanf( ff, "%lf", value_x );
    return 0;
}
 
int IOFUN::read( FILE *ff, long double *value_x )
{
    fscanf( ff, "%Lf", value_x);
    return 0;
}
 
int IOFUN::read( FILE *ff, VECTOR_3D *vec )
{
    fscanf( ff, "%lf%lf%lf", &vec->x, &vec->y, &vec->z );
    return 0;
}