/*

 * 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

gzfilebuf::gzfilebuf()

: file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false),

  buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true)

{

  // No buffers to start with

  this->disable_buffer();

}

// Destructor

gzfilebuf::~gzfilebuf()

{

  // 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

gzfilebuf::setcompression(int comp_level,

                          int comp_strategy)

{

  return gzsetparams(file, comp_level, comp_strategy);

}

// Open gzipped file

gzfilebuf*

gzfilebuf::open(const char *name,

                std::ios_base::openmode mode)

{

  // Fail if file already open

  if (this->is_open())

    return NULL;

  // Don't support simultaneous read/write access (yet)

  if ((mode & std::ios_base::in) && (mode & std::ios_base::out))

    return NULL;

  // Build mode string for gzopen and check it [27.8.1.3.2]

  char char_mode[6] = "\0\0\0\0\0";

  if (!this->open_mode(mode, char_mode))

    return NULL;

  // Attempt to open file

  if ((file = gzopen(name, char_mode)) == NULL)

    return NULL;

  // On success, allocate internal buffer and set flags

  this->enable_buffer();

  io_mode = mode;

  own_fd = true;

  return this;

}

// Attach to gzipped file

gzfilebuf*

gzfilebuf::attach(int fd,

                  std::ios_base::openmode mode)

{

  // Fail if file already open

  if (this->is_open())

    return NULL;

  // Don't support simultaneous read/write access (yet)

  if ((mode & std::ios_base::in) && (mode & std::ios_base::out))

    return NULL;

  // Build mode string for gzdopen and check it [27.8.1.3.2]

  char char_mode[6] = "\0\0\0\0\0";

  if (!this->open_mode(mode, char_mode))

    return NULL;

  // Attempt to attach to file

  if ((file = gzdopen(fd, char_mode)) == NULL)

    return NULL;

  // On success, allocate internal buffer and set flags

  this->enable_buffer();

  io_mode = mode;

  own_fd = false;

  return this;

}

// Close gzipped file

gzfilebuf*

gzfilebuf::close()

{

  // Fail immediately if no file is open

  if (!this->is_open())

    return NULL;

  // Assume success

  gzfilebuf* retval = this;

  // Attempt to sync and close gzipped file

  if (this->sync() == -1)

    retval = NULL;

  if (gzclose(file) < 0)

    retval = NULL;

  // File is now gone anyway (postcondition [27.8.1.3.8])

  file = NULL;

  own_fd = false;

  // Destroy internal buffer if it exists

  this->disable_buffer();

  return retval;

}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

// Convert int open mode to mode string

bool

gzfilebuf::open_mode(std::ios_base::openmode mode,

                     char* c_mode) const

{

  bool testb = mode & std::ios_base::binary;

  bool testi = mode & std::ios_base::in;

  bool testo = mode & std::ios_base::out;

  bool testt = mode & std::ios_base::trunc;

  bool testa = mode & std::ios_base::app;

  // 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, "w");

  if (!testi && testo && !testt && testa)

    strcpy(c_mode, "a");

  if (!testi && testo && testt && !testa)

    strcpy(c_mode, "w");

  if (testi && !testo && !testt && !testa)

    strcpy(c_mode, "r");

  // No read/write mode yet

//  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

  if (strlen(c_mode) == 0)

    return false;

  if (testb)

    strcat(c_mode, "b");

  return true;

}

// Determine number of characters in internal get buffer

std::streamsize

gzfilebuf::showmanyc()

{

  // Calls to underflow will fail if file not opened for reading

  if (!this->is_open() || !(io_mode & std::ios_base::in))

    return -1;

  // Make sure get area is in use

  if (this->gptr() && (this->gptr() < this->egptr()))

    return std::streamsize(this->egptr() - this->gptr());

  else

    return 0;

}

// Fill get area from gzipped file

gzfilebuf::int_type

gzfilebuf::underflow()

{

  // 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 (this->gptr() && (this->gptr() < this->egptr()))

    return traits_type::to_int_type(*(this->gptr()));

  // If the file hasn't been opened for reading, produce error

  if (!this->is_open() || !(io_mode & std::ios_base::in))

    return traits_type::eof();

  // Attempt to fill internal buffer from gzipped file

  // (buffer must be guaranteed to exist...)

  int bytes_read = gzread(file, buffer, buffer_size);

  // Indicates error or EOF

  if (bytes_read <= 0)

  {

    // Reset get area

    this->setg(buffer, buffer, buffer);

    return traits_type::eof();

  }

  // Make all bytes read from file available as get area

  this->setg(buffer, buffer, buffer + bytes_read);

  // Return next character in get area

  return traits_type::to_int_type(*(this->gptr()));

}

// Write put area to gzipped file

gzfilebuf::int_type

gzfilebuf::overflow(int_type c)

{

  // Determine whether put area is in use

  if (this->pbase())

  {

    // Double-check pointer range

    if (this->pptr() > this->epptr() || this->pptr() < this->pbase())

      return traits_type::eof();

    // Add extra character to buffer if not EOF

    if (!traits_type::eq_int_type(c, traits_type::eof()))

    {

      *(this->pptr()) = traits_type::to_char_type(c);

      this->pbump(1);

    }

    // Number of characters to write to file

    int bytes_to_write = this->pptr() - this->pbase();

    // 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

      if (!this->is_open() || !(io_mode & std::ios_base::out))

        return traits_type::eof();

      // If gzipped file won't accept all bytes written to it, fail

      if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write)

        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

  else if (!traits_type::eq_int_type(c, traits_type::eof()))

  {

    // If the file hasn't been opened for writing, produce error

    if (!this->is_open() || !(io_mode & std::ios_base::out))

      return traits_type::eof();

    // Impromptu char buffer (allows "unbuffered" output)

    char_type last_char = traits_type::to_char_type(c);

    // If gzipped file won't accept this character, fail

    if (gzwrite(file, &last_char, 1) != 1)

      return traits_type::eof();

  }

  // If you got here, you have succeeded (even if c was EOF)

  // The return value should therefore be non-EOF

  if (traits_type::eq_int_type(c, traits_type::eof()))

    return traits_type::not_eof(c);

  else

    return c;

}

// Assign new buffer

std::streambuf*

gzfilebuf::setbuf(char_type* p,

                  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 = NULL;

    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

gzfilebuf::sync()

{

  return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0;

}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

// Allocate internal buffer

void

gzfilebuf::enable_buffer()

{

  // If internal buffer required, allocate one

  if (own_buffer && !buffer)

  {

    // Check for buffered vs. "unbuffered"

    if (buffer_size > 0)

    {

      // Allocate internal buffer

      buffer = new char_type[buffer_size];

      // Get area starts empty and will be expanded by underflow as need arises

      this->setg(buffer, buffer, buffer);

      // 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

      this->setp(buffer, buffer + buffer_size - 1);

    }

    else

    {

      // Even in "unbuffered" case, (small?) get buffer is still required

      buffer_size = SMALLBUFSIZE;

      buffer = new char_type[buffer_size];

      this->setg(buffer, buffer, buffer);

      // "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

    this->setg(buffer, buffer, buffer);

    this->setp(buffer, buffer + buffer_size - 1);

  }

}

// Destroy internal buffer

void

gzfilebuf::disable_buffer()

{

  // If internal buffer exists, deallocate it

  if (own_buffer && buffer)

  {

    // Preserve unbuffered status by zeroing size

    if (!this->pbase())

      buffer_size = 0;

    delete[] buffer;

    buffer = NULL;

    this->setg(0, 0, 0);

    this->setp(0, 0);

  }

  else

  {

    // Reset buffer pointers to initial state if external buffer exists

    this->setg(buffer, buffer, buffer);

    if (buffer)

      this->setp(buffer, buffer + buffer_size - 1);

    else

      this->setp(0, 0);

  }

}

/*****************************************************************************/

// Default constructor initializes stream buffer

gzifstream::gzifstream()

: std::istream(NULL), sb()

{ this->init(&sb); }

// Initialize stream buffer and open file

gzifstream::gzifstream(const char* name,

                       std::ios_base::openmode mode)

: std::istream(NULL), sb()

{

  this->init(&sb);

  this->open(name, mode);

}

// Initialize stream buffer and attach to file

gzifstream::gzifstream(int fd,

                       std::ios_base::openmode mode)

: std::istream(NULL), sb()

{

  this->init(&sb);

  this->attach(fd, mode);

}

// Open file and go into fail() state if unsuccessful

void

gzifstream::open(const char* name,

                 std::ios_base::openmode mode)

{

  if (!sb.open(name, mode | std::ios_base::in))

    this->setstate(std::ios_base::failbit);

  else

    this->clear();

}

// Attach to file and go into fail() state if unsuccessful

void

gzifstream::attach(int fd,

                   std::ios_base::openmode mode)

{

  if (!sb.attach(fd, mode | std::ios_base::in))

    this->setstate(std::ios_base::failbit);

  else

    this->clear();

}

// Close file

void

gzifstream::close()

{

  if (!sb.close())

    this->setstate(std::ios_base::failbit);

}

/*****************************************************************************/

// Default constructor initializes stream buffer

gzofstream::gzofstream()

: std::ostream(NULL), sb()

{ this->init(&sb); }

// Initialize stream buffer and open file

gzofstream::gzofstream(const char* name,

                       std::ios_base::openmode mode)

: std::ostream(NULL), sb()

{

  this->init(&sb);

  this->open(name, mode);

}

// Initialize stream buffer and attach to file

gzofstream::gzofstream(int fd,

                       std::ios_base::openmode mode)

: std::ostream(NULL), sb()

{

  this->init(&sb);

  this->attach(fd, mode);

}

// Open file and go into fail() state if unsuccessful

void

gzofstream::open(const char* name,

                 std::ios_base::openmode mode)

{

  if (!sb.open(name, mode | std::ios_base::out))

    this->setstate(std::ios_base::failbit);

  else

    this->clear();

}

// Attach to file and go into fail() state if unsuccessful

void

gzofstream::attach(int fd,

                   std::ios_base::openmode mode)

{

  if (!sb.attach(fd, mode | std::ios_base::out))

    this->setstate(std::ios_base::failbit);

  else

    this->clear();

}

// Close file

void

gzofstream::close()

{

  if (!sb.close())

    this->setstate(std::ios_base::failbit);

}