SIO_stream Class Reference

#include <SIO_stream.h>

Collaboration diagram for SIO_stream:

[legend]List of all members.

Public Member Functions
unsigned int	close ()
void	dump (unsigned int, unsigned int)
std::string *	getName ()
std::string *	getFilename ()
SIO_stream_mode	getMode ()
SIO_stream_state	getState ()
SIO_verbosity	getVerbosity ()
unsigned int	open (const char *, SIO_stream_mode)
unsigned int	read (SIO_record **)
SIO_verbosity	setVerbosity (SIO_verbosity)
unsigned int	write (const char *)
unsigned int	write (SIO_record *)
Private Member Functions
	SIO_stream (const char *, unsigned int, SIO_verbosity)
	~SIO_stream ()
unsigned int	write (SIO_record *, const char *)
Private Attributes
unsigned char *	bufloc
unsigned char *	buffer
unsigned char *	bufmax
unsigned char *	recmax
unsigned char *	blkmax
unsigned char *	cmploc
unsigned char *	cmpmax
z_stream_s *	z_strm
std::string	name
std::string	filename
FILE *	handle
std::string	rec_name
std::string	blk_name
pointedAtMap_c *	pointedAt
pointerToMap_c *	pointerTo
SIO_stream_mode	mode
unsigned int	reserve
SIO_stream_state	state
SIO_verbosity	verbosity
Friends
class	SIO_streamManager
class	SIO_record
class	SIO_functions

---

Constructor & Destructor Documentation

SIO_stream::SIO_stream (  const char *  , unsigned  int, SIO_verbosity  )  [private]

Definition at line 36 of file SIO_stream.cc. References SIO_MODE_UNDEFINED, SIO_STATE_CLOSED, and SIO_verbosity. { bufloc = NULL; buffer = NULL; bufmax = NULL; recmax = NULL; blkmax = NULL; cmploc = NULL; cmpmax = NULL; z_strm = NULL; name = i_name; handle = NULL; mode = SIO_MODE_UNDEFINED; reserve = i_reserve; state = SIO_STATE_CLOSED; verbosity = i_verbosity; }

SIO_stream::~SIO_stream (   )  [private]

Definition at line 66 of file SIO_stream.cc. References close(), SIO_STATE_CLOSED, and state. { // // Always try to close the stream. // if( state != SIO_STATE_CLOSED ) close(); // // That's all folks! // return; }

---

Member Function Documentation

unsigned int SIO_stream::close (   )

Definition at line 84 of file SIO_stream.cc. References blkmax, buffer, bufloc, bufmax, cmploc, cmpmax, filename, handle, mode, name, pointedAt, pointerTo, recmax, SIO_ALL, SIO_ERRORS, SIO_MODE_READ, SIO_MODE_UNDEFINED, SIO_STATE_CLOSED, SIO_STREAM_BADCOMPRESS, SIO_STREAM_GOTEOF, SIO_STREAM_NOTOPEN, SIO_STREAM_SUCCESS, state, verbosity, and z_strm. Referenced by main(), LCDG4_SIOglobal::~LCDG4_SIOglobal(), and ~SIO_stream(). { // // Local variables. // int z_stat; unsigned int status; // // Can't close what ain't open! // if( state == SIO_STATE_CLOSED ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Not open" << std::endl; } return( SIO_STREAM_NOTOPEN ); } // // Assume all will go well. // status = SIO_STREAM_SUCCESS; // // Dispose of the pointer relocation tables. // delete pointedAt; delete pointerTo; // // Dispose of compression control structure. // if( z_strm != NULL ) { z_stat = (mode == SIO_MODE_READ) ? inflateEnd( z_strm ) : deflateEnd( z_strm ); if( z_stat != Z_OK ) { status = SIO_STREAM_BADCOMPRESS; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "ZLIB error number " << z_stat << std::endl; std::cout << "SIO: [" << name << "//] " << "Compression de-initialization failed" << std::endl; } } free( z_strm ); z_strm = NULL; } // // Dispose of any compression/decompression buffer. // if( cmploc != NULL ) { free( cmploc ); cmploc = NULL; cmpmax = NULL; } // // Dispose of any associated raw data buffer. // if( bufloc != NULL ) { free( bufloc ); bufloc = NULL; buffer = NULL; bufmax = NULL; recmax = NULL; blkmax = NULL; } // // Close the stream and destroy associated information. // if( fclose( handle ) == EOF ) { status = SIO_STREAM_GOTEOF; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "EOF on close" << std::endl; } } else { } filename.erase( filename.begin(), filename.end() ); handle = NULL; // // Miscellany. // mode = SIO_MODE_UNDEFINED; state = SIO_STATE_CLOSED; // // Summarize. // if( status == SIO_STREAM_SUCCESS ) { if( verbosity >= SIO_ALL ) { std::cout << "SIO: [" << name << "//] " << "Closed" << std::endl; } } // // That's all folks! // return( status ); }

void SIO_stream::dump (  unsigned  int, unsigned  int )

Definition at line 218 of file SIO_stream.cc. { // // Local variables. // unsigned int count; char *ascpnt, *hexpnt, outbuf[77]; unsigned char *dmpbeg, *dmpend; static char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; // // Header. // printf( "\nDump buffer of stream %s\n\n", name.c_str() ); if( buffer == NULL ) { printf( "No buffer associated with stream %s\n", name.c_str() ); return; } // // Offset must be in bounds. // dmpbeg = bufloc + offset; if( dmpbeg >= bufmax ) { printf( "Offset beyond end of buffer\n"); return; } // // Length must not run off end of buffer. // dmpend = dmpbeg + length; if( dmpend > bufmax ) dmpend = bufmax; // // Buffer characteristics. // printf(" Start address: %8d (0x%08x)\n", (int)bufloc, (int)bufloc ); count = buffer - bufloc; printf(" Current address: %8d (0x%08x) Offset: %8d (0x%08x)\n", (int)buffer, (int)buffer, count, count ); count = bufmax - bufloc; printf(" End address: %8d (0x%08x) Offset: %8d (0x%08x)\n", (int)bufmax, (int)bufmax, count, count ); // // Put out a header. // printf("\n --Offset:Address-"); printf( " -Hex------------------------------"); printf( " -ASCII----------\n"); // dddddddd:xxxxxxxx xxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx aaaaaaaaaaaaaaaa //-123456789-123456789-123456789-123456789-123456789-123456789-123456789-123456 // // Scan down the buffer, printing a dump record every 16 bytes. // memset( &outbuf[ 0], ' ', sizeof( outbuf ) ); sprintf( &outbuf[ 1], "%8d", offset ); sprintf( &outbuf[10], "%08x", (int)dmpbeg ); outbuf[ 9] = ':'; outbuf[18] = ' '; outbuf[76] = '\0'; hexpnt = &outbuf[22]; ascpnt = &outbuf[60]; count = 0; while( dmpbeg < dmpend ) { *hexpnt++ = hex[ ((*dmpbeg >> 4) & 15) ]; *hexpnt++ = hex[ ( *dmpbeg & 15) ]; if( (count & 0x3) == 3 ) hexpnt++; if( isprint( *dmpbeg ) ) *ascpnt++ = *dmpbeg; else *ascpnt++ = '.'; count++; offset++; dmpbeg++; if( count == 16 ) { printf( "%s\n", outbuf ); memset( &outbuf[ 0], ' ', sizeof( outbuf ) ); sprintf( &outbuf[ 1], "%8d", offset ); sprintf( &outbuf[10], "%08x", (int)dmpbeg ); outbuf[ 9] = ':'; outbuf[18] = ' '; outbuf[76] = '\0'; hexpnt = &outbuf[22]; ascpnt = &outbuf[60]; count = 0; } } if( count != 0 ) printf( "%s\n", outbuf ); // // That's all folks! // return; }

std::string * SIO_stream::getFilename (   )

Definition at line 352 of file SIO_stream.cc. References filename. { return( &filename ); }

SIO_stream_mode SIO_stream::getMode (   )

Definition at line 357 of file SIO_stream.cc. References mode, and SIO_stream_mode. { return( mode ); }

std::string * SIO_stream::getName (   )

Definition at line 347 of file SIO_stream.cc. References name. { return( &name ); }

SIO_stream_state SIO_stream::getState (   )

Definition at line 362 of file SIO_stream.cc. References SIO_stream_state, and state. { return( state ); }

SIO_verbosity SIO_stream::getVerbosity (   )

Definition at line 367 of file SIO_stream.cc. References SIO_verbosity, and verbosity. { return( verbosity ); }

unsigned int SIO_stream::open (  const char *  , SIO_stream_mode  )

Definition at line 373 of file SIO_stream.cc. References pointedAtMap_c, pointerToMap_c, SIO_ALL, SIO_ERRORS, SIO_MODE_READ, SIO_MODE_UNDEFINED, SIO_STATE_ERROR, SIO_STATE_OPEN, SIO_STREAM_ALREADYOPEN, SIO_STREAM_BADCOMPRESS, SIO_STREAM_BADMODE, SIO_stream_mode, SIO_STREAM_NOALLOC, SIO_STREAM_OPENFAIL, and SIO_STREAM_SUCCESS. Referenced by LCDG4_SIOglobal::LCDG4_SIOglobal(). { // // Local variables. // int z_stat; static char SIO_filemode[3][3] = { "rb", "wb", "ab" }; // // Can't open what ain't closed! // if( state == SIO_STATE_OPEN || state == SIO_STATE_ERROR ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Already open" << std::endl; } return( SIO_STREAM_ALREADYOPEN ); } // // Can't open in mode undefined. // if( i_mode == SIO_MODE_UNDEFINED ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Cannot open in mode SIO_MODE_UNDEFINED" << std::endl; } return( SIO_STREAM_BADMODE ); } // // Open the file. // if( (handle = fopen( i_filename, SIO_filemode[i_mode] )) == NULL ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Cannot open file " << i_filename << std::endl; } return( SIO_STREAM_OPENFAIL ); } // // Open succeeded. Save the context. // filename = i_filename; mode = i_mode; state = SIO_STATE_OPEN; if( verbosity >= SIO_ALL ) { std::cout << "SIO: [" << name << "//] " << "Opened file " << i_filename << std::endl; } // // Allocate a raw data buffer to go with the stream. // buffer = NULL; bufmax = NULL; bufloc = static_cast<unsigned char*>(malloc( reserve )); if( bufloc == NULL ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Buffer allocation failed" << std::endl; } return( SIO_STREAM_NOALLOC ); } buffer = bufloc; bufmax = bufloc + reserve; // // Allocate a compression/decompression buffer and initialize it. // cmploc = NULL; cmpmax = NULL; cmploc = static_cast<unsigned char*>(malloc( reserve >> 2 )); if( cmploc == NULL ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Compression buffer allocation failed" << std::endl; } return( SIO_STREAM_BADCOMPRESS ); } cmpmax = cmploc + (reserve >> 2); // // Allocate the z_stream structure and initialize it. // z_strm = static_cast<z_stream*>( malloc( sizeof( z_stream ) )); z_strm->zalloc = Z_NULL; z_strm->zfree = Z_NULL; z_strm->opaque = 0; z_stat = (mode == SIO_MODE_READ) ? inflateInit( z_strm ) : deflateInit( z_strm, Z_DEFAULT_COMPRESSION ); if( z_stat != Z_OK ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "ZLIB error number " << z_stat << std::endl; std::cout << "SIO: [" << name << "//] " << "Compression initialization failed" << std::endl; } return( SIO_STREAM_BADCOMPRESS ); } // // Allocate the pointer relocation tables. // pointedAt = new pointedAtMap_c; pointerTo = new pointerToMap_c; // // That's all folks! // return( SIO_STREAM_SUCCESS ); }

unsigned int SIO_stream::read (  SIO_record **   )

Definition at line 529 of file SIO_stream.cc. References SIO_recordManager::get(), SIO_align, SIO_ALL, SIO_DATA, SIO_ERRORS, SIO_LEN_SB, SIO_MODE_READ, SIO_OPT_COMPRESS, SIO_STATE_ERROR, SIO_STATE_OPEN, SIO_STREAM_BADCOMPRESS, SIO_STREAM_EOF, SIO_STREAM_NOALLOC, SIO_STREAM_NORECMARKER, SIO_STREAM_NOTOPEN, and SIO_STREAM_WRITEONLY. { int z_stat; unsigned int data_length, head_length, name_length, ucmp_length, buftyp, compress, padlen, options, status; char *tmploc; bool requested; // // Initialize the returned record pointer to something nasty. // *record = NULL; // // The stream must be open! // if( state != SIO_STATE_OPEN ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Cannot read (stream is not open)" << std::endl; } return( SIO_STREAM_NOTOPEN ); } // // This must be a readable stream! // if( mode != SIO_MODE_READ ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Cannot read (stream is write only)" << std::endl; } return( SIO_STREAM_WRITEONLY ); } // // Loop over records until a requested one turns up. // requested = false; while( requested == false ) { // // Initialize the buffer and read the first eight bytes. A read failure // at this point is treated as an end-of-file (even if there are a few // bytes dangling in the file). // buffer = bufloc; status = fread( buffer, SIO_LEN_SB, 8, handle ); if( status < 8 ) return( SIO_STREAM_EOF ); // // Interpret: 1) The length of the record header. // 2) The record marker. // blkmax = bufloc + 8; SIO_DATA( this, &head_length, 1 ); SIO_DATA( this, &buftyp, 1 ); if( buftyp != SIO_mark_record ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Expected record marker not found" << std::endl; } return( SIO_STREAM_NORECMARKER ); } // // Interpret: 3) The options word. // 4) The length of the record data (compressed). // 5) The length of the record name (uncompressed). // 6) The length of the record name. // 7) The record name. // status = fread( buffer, SIO_LEN_SB, (head_length - 8), handle ); if( status < (head_length - 8) ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Unexpected EOF reading record header" << std::endl; } return( SIO_STREAM_EOF ); } blkmax = bufloc + head_length; SIO_DATA( this, &options, 1 ); SIO_DATA( this, &data_length, 1 ); SIO_DATA( this, &ucmp_length, 1 ); SIO_DATA( this, &name_length, 1 ); tmploc = static_cast<char*>(malloc( name_length + 1 )); if( tmploc == NULL ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Buffer allocation failed" << std::endl; } return( SIO_STREAM_NOALLOC ); } SIO_DATA( this, tmploc, name_length ); tmploc[name_length] = '\0'; *record = SIO_recordManager::get( tmploc ); rec_name = tmploc; free( tmploc ); if( verbosity >= SIO_ALL ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Record header read" << std::endl; } // // Unpack this record? // if( *record == NULL ) { if( verbosity >= SIO_ALL ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Ignored (name not recognized)" << std::endl; } } else if( !(*record)->getUnpack() ) { if( verbosity >= SIO_ALL ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Ignored (unpacking not requested)" << std::endl; } } else { requested = true; } // // If the record's not interesting, move on. Remember to skip over any // padding bytes inserted to make the next record header start on a // four byte boundary in the file. // if( requested == false ) { data_length += (4 - (data_length & SIO_align)) & SIO_align; status = fseek( handle, data_length, 1 ); if( status != 0 ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Failed skipping record" << std::endl; } return( SIO_STREAM_EOF ); } continue; } // // Ensure sufficient buffering for the uncompressed record. // if( (head_length + ucmp_length) >= ((unsigned int)(bufmax - bufloc)) ) { unsigned int newlen; unsigned char *newbuf; newlen = head_length + ucmp_length; newbuf = static_cast<unsigned char*>(malloc( newlen )); if( newbuf == NULL ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Uncompressed buffer allocation failed" << std::endl; } return( SIO_STREAM_NOALLOC ); } memcpy( newbuf, bufloc, head_length ); free( bufloc ); bufloc = newbuf; buffer = newbuf + head_length; bufmax = bufloc + newlen; } // // Extract the compression bit from the options word. // compress = options & SIO_OPT_COMPRESS; if( !compress ) { // // Read the rest of the record data. Note that uncompressed data is // -always- aligned to a four byte boundary in the file, so no pad // skipping is necessary, // status = fread( buffer, SIO_LEN_SB, data_length, handle ); if( status < data_length ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Failed reading uncompressed record data" << std::endl; } return( SIO_STREAM_EOF ); } } else { // // Ensure sufficient buffering for the compressed record. // if( data_length >= (unsigned int)(cmpmax - cmploc) ) { unsigned char *newbuf; newbuf = static_cast<unsigned char*>(malloc( data_length )); if( newbuf == NULL ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Compressed buffer allocation failed" << std::endl; } return( SIO_STREAM_NOALLOC ); } free( cmploc ); cmploc = newbuf; cmpmax = cmploc + data_length; } // // Read the compressed record data. // status = fread( cmploc, SIO_LEN_SB, data_length, handle ); if( status < data_length ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Failed reading compressed record data" << std::endl; } return( SIO_STREAM_EOF ); } // // Skip the read pointer over any padding bytes that may have been // inserted to make the next record header start on a four byte // boundary in the file. // padlen = (4 - (data_length & SIO_align)) & SIO_align; if( padlen > 0 ) { status = fseek( handle, padlen, 1 ); if( status != 0 ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Failed reading end-of-record pad data" << std::endl; } return( SIO_STREAM_EOF ); } } // // Set up for the decompression. // z_strm->next_in = cmploc; z_strm->avail_in = data_length; z_strm->total_in = 0; z_strm->next_out = buffer; z_strm->avail_out = bufmax-buffer; z_strm->total_out = 0; z_stat = inflate( z_strm, Z_FINISH ); if( z_stat != Z_STREAM_END ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "ZLIB error number " << z_stat << std::endl; std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Decompression failed" << std::endl; } return( SIO_STREAM_BADCOMPRESS ); } z_stat = inflateReset( z_strm ); if( z_stat != Z_OK ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "ZLIB error number " << z_stat << std::endl; std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Decompression de-initialization failed" << std::endl; } return( SIO_STREAM_BADCOMPRESS ); } } // // Let the record manager sort out reading all the blocks. // recmax = bufloc + head_length + ucmp_length; status = (*record)->read( this, options ); // // Clear the maps that may have accumulated during record unpacking. // This must be done unconditionally (otherwise tables from a busted // record may persist into the next record). // pointerTo->erase( pointerTo->begin(), pointerTo->end() ); pointedAt->erase( pointedAt->begin(), pointedAt->end() ); if( !( status & 1 ) ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Unpacking error" << std::endl; } } } // // That's all folks! // return( status ); }

SIO_verbosity SIO_stream::setVerbosity (  SIO_verbosity   )

Definition at line 927 of file SIO_stream.cc. References SIO_verbosity. { SIO_verbosity o_verb = verbosity; verbosity = i_verb; return( o_verb ); }

unsigned int SIO_stream::write (  SIO_record *  , const char *  )  [private]

Definition at line 987 of file SIO_stream.cc. References SIO_functions::copy(), SIO_align, SIO_ALL, SIO_DATA, SIO_ERRORS, SIO_LEN_QB, SIO_MODE_READ, SIO_STATE_ERROR, SIO_STATE_OPEN, SIO_STREAM_BADCOMPRESS, SIO_STREAM_BADWRITE, SIO_STREAM_NOALLOC, SIO_STREAM_NOTOPEN, SIO_STREAM_READONLY, SIO_STREAM_SUCCESS, and UCHR_CAST. { // // Local variables. // int z_stat; unsigned int data_length, data_length_off, head_length, head_length_off, name_length, ucmp_length, ucmp_length_off, bufout, compress, newlen, oldlen, options, status; unsigned char *newbuf; static unsigned char pad[4] = { 0, 0, 0, 0 }; // // The stream must be open! // if( state != SIO_STATE_OPEN ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Cannot write (stream is not open)" << std::endl; } return( SIO_STREAM_NOTOPEN ); } // // This must be a writeable stream! // if( mode == SIO_MODE_READ ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "Cannot write (stream is read only)" << std::endl; } return( SIO_STREAM_READONLY ); } // // Capture the record name for error reporting. // rec_name = i_name; // // Initialize the buffer. // buffer = bufloc; // // Output: 1) A placeholder for the record header length. // 2) A 'framing' marker (to help in debugging). // 3) An options word. // 4) A placeholder for the record data length (compressed). // 5) A placeholder for the record data length (uncompressed). // 6) The length of the record name. // 7) The record name. // compress = record->getCompress(); options = record->getOptions(); head_length_off = buffer - bufloc; SIO_DATA( this, &SIO_mark_record, 1 ); SIO_DATA( this, &SIO_mark_record, 1 ); SIO_DATA( this, &options, 1 ); data_length_off = buffer - bufloc; SIO_DATA( this, &SIO_mark_record, 1 ); ucmp_length_off = buffer - bufloc; SIO_DATA( this, &SIO_mark_record, 1 ); name_length = strlen( i_name ); SIO_DATA( this, &name_length, 1 ); SIO_DATA( this, const_cast<char *>(i_name), name_length ); // // Back fill the length of the record header. // head_length = buffer - bufloc; SIO_functions::copy( UCHR_CAST(&head_length), (bufloc + head_length_off), SIO_LEN_QB, 1 ); // // Ask the record object to fill the buffer with blocks. If an error is // reported, just print a complaint and skip writing this buffer. // status = record->write( this ); if( !(status & 1) ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Packing error" << std::endl; } return( status ); } // // Fill in the uncompressed record length. // ucmp_length = (buffer - bufloc) - head_length; SIO_functions::copy( UCHR_CAST(&ucmp_length), (bufloc + ucmp_length_off), SIO_LEN_QB, 1 ); // // Write out the complete record. // if( !compress ) { // // Fill in the written length of the record data (identical with the // uncompressed length when no compression is being performed). // data_length = ucmp_length; SIO_functions::copy( UCHR_CAST(&data_length), (bufloc + data_length_off), SIO_LEN_QB, 1 ); // // When not compressing, both the record header and the record data // can be written in one swell foop. Note that uncompressed data always // satisfies the requirement that it ends on a four byte boundary, so // no padding is required. // data_length += head_length; bufout = fwrite( bufloc, sizeof(char), data_length, handle ); if( bufout != data_length ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "File error writing record" << std::endl; } return( SIO_STREAM_BADWRITE ); } } else { // // Set up for the compression. // z_strm->next_in = bufloc + head_length; z_strm->avail_in = ucmp_length; z_strm->total_in = 0; z_strm->next_out = cmploc; z_strm->avail_out = cmpmax - cmploc; z_strm->total_out = 0; // // Loop the compression in case the compression buffer is not big enough. // for(;;) { z_stat = deflate( z_strm, Z_FINISH ); if( z_strm->avail_out > 0 ) break; newlen = (cmpmax - cmploc) << 1; newbuf = static_cast<unsigned char*>(malloc( newlen )); if( newbuf == NULL ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "//] " << "Compression buffer allocation failed" << std::endl; } state = SIO_STATE_ERROR; return( SIO_STREAM_NOALLOC ); } oldlen = z_strm->next_out - cmploc; memcpy( newbuf, cmploc, oldlen ); free( cmploc ); cmploc = newbuf; cmpmax = cmploc + newlen; z_strm->next_out = cmploc + oldlen; z_strm->avail_out = cmpmax - z_strm->next_out; if( verbosity >= SIO_ALL ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "Allocated a " << newlen << "(0x" << std::hex << newlen << std::dec << ")" << " byte compression buffer" << std::endl; } } z_stat = deflateReset( z_strm ); if( z_stat != Z_OK ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "//] " << "ZLIB error number " << z_stat << std::endl; std::cout << "SIO: [" << name << "//] " << "Compression de-initialization failed" << std::endl; } return( SIO_STREAM_BADCOMPRESS ); } // // Fill in the length of the compressed buffer. // data_length = z_strm->next_out - cmploc; SIO_functions::copy( UCHR_CAST(&data_length), (bufloc + data_length_off), SIO_LEN_QB, 1 ); // // Write the record header. // bufout = fwrite( bufloc, sizeof(char), head_length, handle ); if( bufout != head_length ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "File error writing record header" << std::endl; } return( SIO_STREAM_BADWRITE ); } // // Write the compressed record data. // bufout = fwrite( cmploc, sizeof(char), data_length, handle ); if( bufout != data_length ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "File error writing record content" << std::endl; } return( SIO_STREAM_BADWRITE ); } // // Insert any necessary padding to make the next record header start // on a four byte boundary in the file (to make it directly accessible // for xdr read). // newlen = (4 - (data_length & SIO_align)) & SIO_align; if( newlen > 0 ) { bufout = fwrite( pad, sizeof(char), newlen, handle ); if( bufout != newlen ) { state = SIO_STATE_ERROR; if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << rec_name << "/] " << "File error writing end-of-record pad" << std::endl; } return( SIO_STREAM_BADWRITE ); } } } // // Clear the maps that may have accumulated during record writing. // pointerTo->erase( pointerTo->begin(), pointerTo->end() ); pointedAt->erase( pointedAt->begin(), pointedAt->end() ); // // That's all folks! // return( SIO_STREAM_SUCCESS ); }

unsigned int SIO_stream::write (  SIO_record *   )

Definition at line 972 of file SIO_stream.cc. { // // Call the workhorse. // return( write( record, record->getName()->c_str() ) ); }

unsigned int SIO_stream::write (  const char *   )

Definition at line 936 of file SIO_stream.cc. References SIO_recordManager::get(), SIO_ERRORS, and SIO_STREAM_NOSUCHRECORD. Referenced by LCDG4EventAction::EndOfEventAction(), and LCDG4_SIOglobal::LCDG4_SIOglobal(). { // // Local variables. // SIO_record *record; // // Validate the record name. // record = SIO_recordManager::get( i_name ); if( record == NULL ) { if( verbosity >= SIO_ERRORS ) { std::cout << "SIO: [" << name << "/" << i_name << "//] " << "Record name not recognized" << std::endl; } return( SIO_STREAM_NOSUCHRECORD ); } // // Call the workhorse. // return( write( record, i_name ) ); }

---

Friends And Related Function Documentation

friend class SIO_functions [friend]

Definition at line 84 of file SIO_stream.h.

friend class SIO_record [friend]

Definition at line 83 of file SIO_stream.h.

friend class SIO_streamManager [friend]

Definition at line 82 of file SIO_stream.h.

---

Member Data Documentation

std::string SIO_stream::blk_name [private]

Definition at line 72 of file SIO_stream.h.

unsigned char* SIO_stream::blkmax [private]

Definition at line 61 of file SIO_stream.h. Referenced by close().

unsigned char* SIO_stream::buffer [private]

Definition at line 58 of file SIO_stream.h. Referenced by close().

unsigned char* SIO_stream::bufloc [private]

Definition at line 57 of file SIO_stream.h. Referenced by close().

unsigned char* SIO_stream::bufmax [private]

Definition at line 59 of file SIO_stream.h. Referenced by close().

unsigned char* SIO_stream::cmploc [private]

Definition at line 63 of file SIO_stream.h. Referenced by close().

unsigned char* SIO_stream::cmpmax [private]

Definition at line 64 of file SIO_stream.h. Referenced by close().

std::string SIO_stream::filename [private]

Definition at line 68 of file SIO_stream.h. Referenced by close(), and getFilename().

FILE* SIO_stream::handle [private]

Definition at line 69 of file SIO_stream.h. Referenced by close().

SIO_stream_mode SIO_stream::mode [private]

Definition at line 77 of file SIO_stream.h. Referenced by close(), and getMode().

std::string SIO_stream::name [private]

Definition at line 67 of file SIO_stream.h. Referenced by close(), and getName().

pointedAtMap_c* SIO_stream::pointedAt [private]

Definition at line 74 of file SIO_stream.h. Referenced by close().

pointerToMap_c* SIO_stream::pointerTo [private]

Definition at line 75 of file SIO_stream.h. Referenced by close().

std::string SIO_stream::rec_name [private]

Definition at line 71 of file SIO_stream.h.

unsigned char* SIO_stream::recmax [private]

Definition at line 60 of file SIO_stream.h. Referenced by close().

unsigned int SIO_stream::reserve [private]

Definition at line 78 of file SIO_stream.h.

SIO_stream_state SIO_stream::state [private]

Definition at line 79 of file SIO_stream.h. Referenced by close(), getState(), and ~SIO_stream().

SIO_verbosity SIO_stream::verbosity [private]

Definition at line 80 of file SIO_stream.h. Referenced by close(), and getVerbosity().

struct z_stream_s* SIO_stream::z_strm [private]

Definition at line 65 of file SIO_stream.h. Referenced by close().

---

The documentation for this class was generated from the following files:

• SIO_stream.h
• SIO_stream.cc

---