Search  

---

C:/temp/src/j2k/Fred/JFile.cpp

Go to the documentation of this file.

#ifndef __J2K__JFile_CPP__
#define __J2K__JFile_CPP__

#include <assert.h>
#include <j2k/Fred/JFile.hpp>

JFile::JFile() 
 : f( NULL ), fmode( "rb" ), recsize( 0 ), 
   fpath( NULL ), fpos( 0 ), current( 0 ) { }

FILE* JFile::F() {
    assert( f != NULL ); // More sophisticated test needed.
  return f;
}

/*
The fopen() function opens a file stream for the file specified by filename. 
The mode string begins with one of the following sequences: 

a   Append: create a new file or open the file for writing at its end. 
a+  Append: open the file or create it for update, writing at end-of-file; 
    use the default file translation. 

r   Open the file for reading. 
r+  Open the file for update (reading and/or writing); 
    use the default file translation. 

w   Create the file for writing, or truncate it to zero length. 
w+  Create the file for update, or truncate it to zero length; 
    use the default file translation. 

You can add the letter b to the end of any of the above sequences to indicate 
that the file is (or must be) a binary file (this is an ANSI requirement 
for portability to systems that make a distinction between text
and binary files, such as DOS).

Opening a file in read mode (r in the mode) fails if the file doesn't exist 
or can't be read. Opening a file in append mode (a in the mode) causes 
all subsequent writes to the file to be forced to the current end-of-file, 
regardless of previous calls to the fseek() function. 
When a file is opened with update mode (+ in the mode), 
both input and output may be performed on the associated stream. 
*/

JFile::JFile( const char* path, const char* mode, size_t recordsize ) 
: fpath( path ), fmode( mode ), recsize( recordsize ), fpos( 0 ), current( 0 )
{ 
  printf( "\nOpening %s...\n", path ); 
  f = ::fopen( path, mode );
  if ( f == NULL ) {
    printf("Unable to open: %s \n", path );
    MC_OnError( errno, Error, "while opening a JFile." )
 // TFTP_FileNotFoundErrorHandler( Error, (JErrorNo)2, "can't open file", __LINE__, __FILE__ );
    exit(1);
  }
}


/*
The fclose() function closes the stream specified by fp. 
Any unwritten, buffered data is flushed before the file is closed. 
Any unread, buffered data is discarded. 
If the associated buffer was automatically allocated, it is deallocated.
*/
JFile::~JFile() {
  if ( f != NULL ) {
    if ( fclose(f) == EOF ) {
      printf("Unable to close: %s \n", fpath );
      MC_OnError( errno, Error, "while closing a JFile." )
    }
  }
}

// Buffer provided just copy over...
void JFile::getFileName( char* buffer )
{
  long len = strlen( fpath );
  long   p   = len;

  for( ; p >= 0; p-- ) {
    if ( fpath[p] == '\\' || fpath[p] == '/' ) {
      memcpy( buffer, (fpath + p + 1), (len - p + 1) );
      return;
    }
  }

  // Direct filename, no path included.
  memcpy( buffer, fpath, len );
}

// No buffer provided
char* JFile::getFileName()
{    
  size_t len = strlen( fpath );
  char* s = new char[ len ];  
  memset( s, 0, len );

  getFileName( s );

  return s;
}

/*
The open stream fp is closed, and the file specified by filename is opened, 
associating its stream with fp. 

The mode is described in the description of the fopen() function.
*/

void JFile::reopen() {
  f = ::freopen( fpath, fmode, f );
  if ( f == NULL ) {
    printf("Unable to reopen: %s \n", fpath );
    MC_OnError( errno, Error, "while reopening a JFile." )
    exit(1);
  }
}

/* Read a character from a stream
   The next character from fp,
   cast as (int)(unsigned char),
   or EOF if end-of-file has been reached
   or if an error occurs (errno is set).
*/
int JFile::getChar() {
  int c = fgetc( F() );
  MC_OnError( errno, Error, "while retrieving a character from a JFile." )  
  return c;
}

long JFile::getData( char* buffer, size_t length )
{
  memset( buffer, 0, length );
  long p = 0;
  long neof = 1;
  for( ; p < (long)length; p++ ) {

    int c = fgetc( F() );
//    char c;
//    size_t rc = readChar( &c );
    if ( c == EOF ) { neof = -1; break; }
    MC_OnError( errno, Error, "while retrieving data from a JFile." )
    buffer[ p ] = (char)c;
  }
  p++;
  printf("[%u|%u]", p, length );
  if ( p == (long)length ) addCurrent( (long)length );
  return p * neof;
}

/* Push a character back onto an input stream

The ungetc() function pushes the character specified by c 
back onto the input stream pointed to by fp. 
This character will be returned by the next read on the stream. 
The pushed-back character is discarded if a call is made 
to the fflush() function or to a file-positioning function 
(fseek(), fsetpos() or rewind()) before the next read operation is performed. 
*/
inline int JFile::ungetChar( int c ) {
  // No errno set in any case.
  return ::ungetc( c, F() );  
}


/* Write a character to a stream
The fputc() function writes the character specified by c, 
cast as (int)(unsigned char), to the stream specified by fp.

The character written, cast as (int)(unsigned char),
or EOF if an error occurred (errno is set).
*/
void JFile::putChar( int c ) {
  register int rc = ::fputc( c, F() );
  MC_OnError( errno, Error, "while saving a character inside a JFile." )   
}

size_t JFile::putData( char* buffer, long length, long blocksize )
{
  size_t p  = 0;
  int    rc = 0;
  int    c  = 0;
  int    z  = 0;
  printf("\nlength=%u|%u{", length, blocksize );
  for( p = 0; (long)p < length; p++ )
  {
    c  = (int)buffer[p];
    if ( c == 0 ) z++;
  }

  printf("(%u)", z );
  fflush( stdout );
  if ( z >= 3 ) return 0;

  for( p = 0; (long)p < length; p++ )
  {
    c  = (int)buffer[p];
    printf( "[%u]", (char)c );
    rc = fputc( c, F() );
    MC_OnError( errno, Error, "while saving data from a JFile." )
  }
  printf("}\n");
  fflush( stdout);

//  p++;
#ifdef DEBUG
  printf( "PutData[%s|%d=%d,%d,%d]", buffer, length, p, c, rc );
#endif
  if ( (long)p == length ) addCurrent( length );
  return p;
}


/*
Write a string to an output stream
The fputs() function writes the character string specified by buf 
to the output stream specified by fp. 
The terminating NULL character is not written.

A nonnegative value for success, or EOF if an error occurs (errno is set).
*/
void JFile::putStr( const char* s ) {
  register int c = ::fputs( s, F() );
  if ( c < 0 ) {
    MC_OnError( errno, Error, "while saving a string inside a JFile." )
  }
}

/*
Read a string of characters from a stream
The fgets() function reads a string of characters from the stream 
specified by fp, and stores them in the array specified by buf. 

It stops reading characters when: 

the end-of-file is reached 
Or: 

a newline ('\n') character is read 
Or: 

n-1 characters have been read. 
The newline character isn't discarded. 
A null character is placed immediately
after the last character read into the array.

----------------------------------------------------------------------------
 Don't assume the presence of a newline character in every string
 that is read with fgets(). A newline character isn't be present
 when more than n-1 characters occur before the newline.
 Also, a newline character might not appear as the last character
 in a file when the end-of-file is reached.
----------------------------------------------------------------------------
The same pointer as buf for success,
or NULL if the stream is at the end-of-file
or an error occurs (errno is set).
*/
char* JFile::getStr( char* s, int n ) {
  register char* rc = ::fgets( s, n, F() );
  if ( rc == NULL ) {
    MC_OnError( errno, Error, "while retrieving a string from a JFile." )  
  }
  return s;
}

/*
Write formatted output to a file

The vfprintf() function writes output to the file pointed to by fp, 
under control of the argument format. 

The vfprintf() function is equivalent to the fprintf() function, 
with the variable argument list replaced with arg, 
which has been initialized by the va_start() macro.

Returns:
The number of characters written, 
or a negative value if an output error occurred (errno is set).
*/
int JFile::print( const char* format, ... )
{
   register int cnt;
   va_list argptr;
   va_start(argptr, format);
   cnt = ::vfprintf(F(), format, argptr );
   va_end(argptr);

   if ( cnt < 0 ) {
     MC_OnError( errno, Error, "while printing a formated string inside a JFile." )  
   }
   return cnt;
}

/*
Read elements from a file
The fread() function reads num elements of size bytes each 
from the stream specified by fp into the buffer specified by buf.

Returns:
The number of complete elements successfully read; 
this value may be less than the requested number of elements. 

Use the feof() and ferror() functions to determine 
whether the end of the file was encountered or if an input/output error has occurred.
*/

size_t JFile::readChar( char* c ) {
  return read( c, 1, 1 );
}

size_t JFile::read( void* ptr, size_t size, size_t n ) 
{
  register size_t rc = ::fread( ptr, size, n, F() );

  if (  ferror( F() )  ) {
    printf( "Error while reading elements from a JFile: %s\n", fpath );
    MC_OnError( errno, Error, "while retrieving  elements from a JFile." )
    exit( 1 );
  }
        
  if (  feof( F() )    ) {
    printf( "End of file reached.\n" );
    return (size_t)(-1);
  }

  return rc;
}

/*
Write elements to a file
The fwrite() function writes num elements of size bytes each
to the stream specified by fp.

Returns:
The number of complete elements successfully written; 
if an error occurs, this will be less than num.
*/
size_t JFile::write( const void* ptr, size_t size, size_t n ) 
{
  register size_t rc = ::fwrite(ptr, size, n, F());
  MC_OnError( errno, Error, "while writing elements inside a JFile." )  
  return rc;
}

/*
Test a stream's end-of-file flag
The feof() function tests the end-of-file flag for the stream specified by fp. 

Because the end-of-file flag is set when an input operation attempts 
to read past the end-of-file, the feof() function detects the end-of-file 
only after an attempt is made to read beyond the end-of-file. 
Thus, if a file contains 10 lines, the feof() won't detect the end-of-file 
after the tenth line is read; it will detect the end-of-file on the next read operation.

Returns:
0 if the end-of-file flag isn't set, or nonzero if the end-of-file flag is set.
*/
int JFile::eof() { 
  return feof( F() ); 
}

/*
Flush the buffers for a stream

If the stream specified by fp is open for output or update, 
the fflush() function causes any buffered (see setvbuf()) 
but unwritten data to be written to the file descriptor associated 
with the stream (see fileno()). 

If the file specified by fp is open for input or update, 
the fflush() function undoes the effect of any preceding ungetc operation on the stream. 

If fp is NULL all open streams are flushed.

Returns:
0 for success, or EOF if an error occurs (errno is set).
*/
int JFile::flush() { 
  return ::fflush( F() ); 
}

/*
Change the current position of a stream

The fseek() function changes the current position of the stream specified by fp. 
This position defines the character that will be read or written 
by the next I/O operation on the file. fp is a FILE pointer 
returned by fopen() or freopen(). The offset is the position to seek to, 
relative to one of three positions specified by whence. 

Valid whence values are: 

SEEK_SET 
The new file position is computed relative to the start of the file. 
The value of offset must not be negative. 

SEEK_CUR 
The new file position is computed relative to the current file position. 
The value of offset may be positive, negative or zero. 
A SEEK_CUR with a 0 offset is necessary when you want to switch 
from reading to writing on a stream opened for updates. 

SEEK_END 
The new file position is computed relative to the end of the file. 
The fseek() function clears the end-of-file indicator, 
and undoes any effects of the ungetc() function on the stream. 

The ftell() function can be used to get the current position of the stream 
before changing it. The position can be restored by using the value 
returned by ftell() in a subsequent call to fseek() 
with the whence parameter set to SEEK_SET.

Returns:
0 for success, or nonzero if an error occurs.
*/
int JFile::seek( long offset, int whence )
{
  register int rc = ::fseek(F(), offset, whence);
  if ( rc != 0 ) {
    MC_OnError( errno, Error, "while seeking inside a JFile." )
  }
  return rc;
}

/*
Get the current position of a stream

The fgetpos() function stores the current position of the stream fp 
in the fpos_t object specified by pos. 

The value stored in pos can be used by fsetpos() for repositioning 
the file to the position at the time of the fgetpos() call.

Returns:
0 for success, or nonzero if an error occurs (errno is set).
*/
int JFile::getpos( fpos_t* pos ) {
  register int rc = ::fgetpos(F(), pos);
  if ( rc != 0 ) {
    MC_OnError( errno, Error, "while retrieving the current position inside a JFile." )
  }
  return rc;
}

/*
Set the current position of a file

The fsetpos() function sets the current position of the stream specified 
by fp according to the value of the fpos_t object pointed to by pos. 

The value pointed to by pos must have been set by a call to fgetpos() on the same file.

Returns:
0 for success, or nonzero if an error occurs (errno is set).

*/

int JFile::setpos( const fpos_t* pos ) {
  register int rc = ::fsetpos(F(), pos);
  if ( rc != 0 ) {
    MC_OnError( errno, Error, "while setting the current position inside a JFile." )
  }
  return rc;
}

void JFile::setBegin( long offset ) {
  register int rc = ::fseek(F(), offset, SEEK_SET );
  if ( rc != 0 ) {
    MC_OnError( errno, Error, "while seeking inside a JFile." )
  }
}

#if 0
void JFile::addCurrent( long offset ) {
  current += offset;
  printf("OFFSET=%u\n", current );
  fflush( stdout );
  register int rc = ::fseek(F(), offset, SEEK_CUR );
  if ( rc != 0 ) {
    MC_OnError( errno, Error, "while seeking inside a JFile." )
  }
}
#endif

void JFile::addCurrent( long offset ) {
  current += offset;
  printf("OFFSET=%u\n", current );
  fflush( stdout );
  register int rc = ::fseek(F(), current, SEEK_SET );
  if ( rc != 0 ) {
    MC_OnError( errno, Error, "while seeking inside a JFile." )
  }
}

void JFile::setEnd( long offset ) {
  register int rc = ::fseek(F(), offset, SEEK_END );
  if ( rc != 0 ) {
    MC_OnError( errno, Error, "while seeking inside a JFile." )
  }
}

/*
Return the current position of a stream

The ftell() function returns the current position of the stream specified by fp. 
This position defines the character that will be read or written 
by the next I/O operation on the file. The value returned by ftell() 
can be used in a subsequent call to fseek() to restore the file position 
to a previous value. 

Returns:
The current position of the file or -1L if an error occurred (errno is set).
*/
long JFile::tell() {
  register long rc = ::ftell( F() );
  if ( rc < 0 ) {
    MC_OnError( errno, Error, "while getting the current position inside a JFile." )
  }

  return rc;
}

/*
Rewind a file stream to the beginning of the file

The rewind() function rewinds the file stream specified by fp to the beginning 
of the file. It's equivalent to calling fseek() like this: 

fseek( fp, 0L, SEEK_SET );
except that the error indicator for the stream is cleared.
*/
void JFile::rewind() {
  ::rewind( F() );
  MC_OnError( errno, Error, "while rewinding a JFile." )
}

void JFile::setbuf( char* buf ) {
  ::setbuf(F(), buf);
  MC_OnError( errno, Error, "while setting a JFile buffer." )
}

int JFile::setvbuf( char* buf, int type, size_t sz ) {
  int rc = ::setvbuf(F(), buf, type, sz);
  MC_OnError( errno, Error, "while setting a formated JFile buffer." )
  return rc;
}

/*
Test a stream's error flag
The ferror() function tests the error flag for the stream specified by fp.

Returns:
0 if the error flag isn't set, or nonzero if the error flag is set.
*/
int JFile::error() {
  register int rc = ferror( F() );
  MC_OnError( errno, Error, "while checking for a JFile error." )
  return rc;
}

void JFile::clearError() {
  clearerr( F() );
  MC_OnError( errno, Error, "while clearing a JFile error." )
}

/*
fich= fopen (nom_du_fichier, "rb");
fseek (fich, 0, SEEK_END);
taille_fichier= ftell (fich)
;fclose (fich);
*/

size_t JFile::getFileSize()
{
   struct stat value;

   int result = ::stat( fpath, &value );

   //fstat( F(), &value );

   // Validate data
   assert( result != 0 );

   MC_OnError( errno, Error, "while getting a JFile size." )
 
   // File Size     
   return ( value.st_size );
}

#endif

---