zfstream.cc revision 1b33c96954667ba382fa595baf7b31290bfdd517
/*
* A C++ I/O streams interface to the zlib gz* functions
*
* by Ludwig Schwardt <schwardt@sun.ac.za>
* original version by Kevin Ruland <kevin@rodin.wustl.edu>
*
* This version is standard-compliant and compatible with gcc 3.x.
*/
#include "zfstream.h"
#include <cstring> // for strcpy, strcat, strlen (mode strings)
#include <cstdio> // for BUFSIZ
// Internal buffer sizes (default and "unbuffered" versions)
#define BIGBUFSIZE BUFSIZ
#define SMALLBUFSIZE 1
/*****************************************************************************/
// Default constructor
{
// No buffers to start with
this->disable_buffer();
}
// Destructor
{
// Sync output buffer and close only if responsible for file
// (i.e. attached streams should be left open at this stage)
this->sync();
if (own_fd)
this->close();
// Make sure internal buffer is deallocated
this->disable_buffer();
}
// Set compression level and strategy
int
int comp_strategy)
{
}
// Open gzipped file
{
// Fail if file already open
if (this->is_open())
return NULL;
return NULL;
// Build mode string for gzopen and check it [27.8.1.3.2]
return NULL;
// Attempt to open file
return NULL;
// On success, allocate internal buffer and set flags
this->enable_buffer();
own_fd = true;
return this;
}
// Attach to gzipped file
{
// Fail if file already open
if (this->is_open())
return NULL;
return NULL;
// Build mode string for gzdopen and check it [27.8.1.3.2]
return NULL;
// Attempt to attach to file
return NULL;
// On success, allocate internal buffer and set flags
this->enable_buffer();
own_fd = false;
return this;
}
// Close gzipped file
{
// Fail immediately if no file is open
if (!this->is_open())
return NULL;
// Assume success
// Attempt to sync and close gzipped file
if (this->sync() == -1)
// File is now gone anyway (postcondition [27.8.1.3.8])
own_fd = false;
// Destroy internal buffer if it exists
this->disable_buffer();
return retval;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Convert int open mode to mode string
bool
char* c_mode) const
{
// Check for valid flag combinations - see [27.8.1.3.2] (Table 92)
// Original zfstream hardcoded the compression level to maximum here...
// Double the time for less than 1% size improvement seems
// excessive though - keeping it at the default level
// To change back, just append "9" to the next three mode strings
// if (testi && testo && !testt && !testa)
// strcpy(c_mode, "r+");
// if (testi && testo && testt && !testa)
// strcpy(c_mode, "w+");
// Mode string should be empty for invalid combination of flags
return false;
if (testb)
return true;
}
// Determine number of characters in internal get buffer
{
// Calls to underflow will fail if file not opened for reading
return -1;
// Make sure get area is in use
else
return 0;
}
// Fill get area from gzipped file
{
// If something is left in the get area by chance, return it
// (this shouldn't normally happen, as underflow is only supposed
// to be called when gptr >= egptr, but it serves as error check)
// If the file hasn't been opened for reading, produce error
return traits_type::eof();
// Attempt to fill internal buffer from gzipped file
// (buffer must be guaranteed to exist...)
// Indicates error or EOF
if (bytes_read <= 0)
{
// Reset get area
return traits_type::eof();
}
// Make all bytes read from file available as get area
// Return next character in get area
}
// Write put area to gzipped file
{
// Determine whether put area is in use
if (this->pbase())
{
// Double-check pointer range
return traits_type::eof();
// Add extra character to buffer if not EOF
{
this->pbump(1);
}
// Number of characters to write to file
// Overflow doesn't fail if nothing is to be written
if (bytes_to_write > 0)
{
// If the file hasn't been opened for writing, produce error
return traits_type::eof();
// If gzipped file won't accept all bytes written to it, fail
return traits_type::eof();
// Reset next pointer to point to pbase on success
this->pbump(-bytes_to_write);
}
}
// Write extra character to file if not EOF
{
// If the file hasn't been opened for writing, produce error
return traits_type::eof();
// Impromptu char buffer (allows "unbuffered" output)
// If gzipped file won't accept this character, fail
return traits_type::eof();
}
// If you got here, you have succeeded (even if c was EOF)
// The return value should therefore be non-EOF
return traits_type::not_eof(c);
else
return c;
}
// Assign new buffer
std::streamsize n)
{
// First make sure stuff is sync'ed, for safety
if (this->sync() == -1)
return NULL;
// If buffering is turned off on purpose via setbuf(0,0), still allocate one...
// "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at
// least a buffer of size 1 (very inefficient though, therefore make it bigger?)
// This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems)
if (!p || !n)
{
// Replace existing buffer (if any) with small internal buffer
this->disable_buffer();
buffer_size = 0;
own_buffer = true;
this->enable_buffer();
}
else
{
// Replace existing buffer (if any) with external buffer
this->disable_buffer();
buffer = p;
buffer_size = n;
own_buffer = false;
this->enable_buffer();
}
return this;
}
// Write put area to gzipped file (i.e. ensures that put area is empty)
int
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Allocate internal buffer
void
{
// If internal buffer required, allocate one
if (own_buffer && !buffer)
{
// Check for buffered vs. "unbuffered"
if (buffer_size > 0)
{
// Allocate internal buffer
// Get area starts empty and will be expanded by underflow as need arises
// Setup entire internal buffer as put area.
// The one-past-end pointer actually points to the last element of the buffer,
// so that overflow(c) can safely add the extra character c to the sequence.
// These pointers remain in place for the duration of the buffer
}
else
{
// Even in "unbuffered" case, (small?) get buffer is still required
// "Unbuffered" means no put buffer
this->setp(0, 0);
}
}
else
{
// If buffer already allocated, reset buffer pointers just to make sure no
// stale chars are lying around
}
}
// Destroy internal buffer
void
{
// If internal buffer exists, deallocate it
if (own_buffer && buffer)
{
// Preserve unbuffered status by zeroing size
if (!this->pbase())
buffer_size = 0;
delete[] buffer;
this->setg(0, 0, 0);
this->setp(0, 0);
}
else
{
// Reset buffer pointers to initial state if external buffer exists
if (buffer)
else
this->setp(0, 0);
}
}
/*****************************************************************************/
// Default constructor initializes stream buffer
// Initialize stream buffer and open file
{
}
// Initialize stream buffer and attach to file
{
}
// Open file and go into fail() state if unsuccessful
void
{
else
this->clear();
}
// Attach to file and go into fail() state if unsuccessful
void
{
else
this->clear();
}
// Close file
void
gzifstream::close()
{
}
/*****************************************************************************/
// Default constructor initializes stream buffer
// Initialize stream buffer and open file
{
}
// Initialize stream buffer and attach to file
{
}
// Open file and go into fail() state if unsuccessful
void
{
else
this->clear();
}
// Attach to file and go into fail() state if unsuccessful
void
{
else
this->clear();
}
// Close file
void
gzofstream::close()
{
}