A GZIP compressed CSV writer. More...

#include <GZCSVFileWriter.h>

Public Member Functions
	STANDARD_TYPEDEF (sella::file::GZCSVFileWriter)

	GZCSVFileWriter (const std::string &file, char delimiter=DefaultDelimiter, char seperator=DefaultSeperator) THROWS(IOException)

virtual	~GZCSVFileWriter () NO_EXCEPTIONS

void	write (const std::vector< std::string > &data) THROWS(IOException)

void	close (const std::string &rename=std::string()) THROWS(IOException)

Static Public Attributes
static const char	DefaultDelimiter = 0x1e
	The default delimiter used between the fields of a record; the ASCII record seperator character.

static const char	DefaultSeperator = 0x1d
	The default seperator used between the records of a file; the ASCII group seperator character.

Protected Member Functions
void	write (uint8_t *input, ssize_t length, int flush) THROWS(IOException)

Detailed Description

A GZIP compressed CSV writer.

Definition at line 31 of file GZCSVFileWriter.h.

Constructor & Destructor Documentation

GZCSVFileWriter::GZCSVFileWriter	(	const std::string &	file,
		char	delimiter = `DefaultDelimiter`,
		char	seperator = `DefaultSeperator`
	)

The base constructor for a file writer.

Parameters

[in]	file	The name of the file to write.
[in]	delimiter	The field delimiter character for this file.
[in]	seperator	The record seperator character for this file.

Exceptions

IOException if the file cannot be opened for writing.

Definition at line 26 of file GZCSVFileWriter.cpp.

                                                                                                            :
         filename(file),
 
         delimiter(delimiter),
         seperator(seperator),
 
         descriptor(::open(file.c_str(), O_WRONLY | O_LARGEFILE | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH))
 {
         /* Ensure the file was opened for writing, and zero all buffers and state machines. */
         if (this->descriptor <= 0) {
                 THROW(IOException, "failed to open file '%s' for writing", this->filename.c_str());
         }
         memset(&(this->stream), 0, sizeof(this->stream));
         memset(&(this->buffer), 0, sizeof(this->buffer));
 
         /* Initialize for the writing of GZIP compressed files. */
         if (::deflateInit2(&(this->stream), 9 /* Best Compression */, Z_DEFLATED, 16 + MAX_WBITS /* GZIP */, 9 /* Maximum Memory and Speed */, Z_DEFAULT_STRATEGY) != Z_OK) {
                 ::close(this->descriptor);
 
                 THROW(IOException, "failed to initilize zlib instance for writing file '%s'", this->filename.c_str());
         }
 }

GZCSVFileWriter::~GZCSVFileWriter ( )

virtual

The class destructor; this destructor closes the file opened by this instance if it was not explicitly closed by the class user.

Definition at line 53 of file GZCSVFileWriter.cpp.

References close().

                                                 {
         if (this->descriptor != 0) {
                 ::deflateEnd(&(this->stream));
 
                 this->close();
         }
 }

Member Function Documentation

void GZCSVFileWriter::close ( const std::string & rename = std::string() )

Close the file opened by this instance. Failure to explicitly call this function will not cause a file descriptor leak if the class destructor is called: the destructor will call close() automatically if necessary.

Parameters

[in] rename When set to a non-zero length string, the file will be renamed to the value in rename after closing.

Definition at line 165 of file GZCSVFileWriter.cpp.

Referenced by ~GZCSVFileWriter().

                                                                         {
         uint8_t buffer[4];
 
         /* Close the compression stream out. */
         this->write(buffer, 0, Z_FINISH);
         
         ::close(this->descriptor);
 
         if (rename.length() > 0) {
                 ::rename(this->filename.c_str(), rename.c_str());
         }
         this->filename.clear();
         this->descriptor = 0;
 }

void GZCSVFileWriter::write ( const std::vector< std::string > & data )

Append the next record to the file.

Parameters

[in] data The vector which contains all fields of the record.

Exceptions

IOException if unabled to write the next record for any reason.

Definition at line 68 of file GZCSVFileWriter.cpp.

                                                                                  {
         size_t length = 0;
 
         /* Write all fields, one at a time, to the compression stream. */
         for (auto iter = data.begin(); iter != data.end(); ++iter) {
                 ssize_t offset = 0;
 
                 /* Append the field delimiter if this is not the first field of the record. */
                 if (iter != data.begin()) {
                         /* Purge the buffer if required to make room for the field delimiter. */
                         if (sizeof(this->delimiter) > (sizeof(this->buffer[1]) - length)) {
                                 this->write(this->buffer[1], length, Z_NO_FLUSH);
 
                                 length = 0;
                         }
                         this->buffer[1][length++] = this->delimiter;
                 }
 
                 do { /* Append the field value to the buffer. */
                         /* Copy as much of the field value as possible to the buffer. */
                         if ((iter->length() - offset) > (sizeof(this->buffer[1]) - length)) {
                                 ::memcpy(&(this->buffer[1][length]), &(iter->c_str()[offset]), sizeof(this->buffer[1]) - length);
 
                                 this->write(this->buffer[1], sizeof(this->buffer[1]), Z_NO_FLUSH);
 
                                 offset += (sizeof(this->buffer[1]) - length);
                                 length = 0;
                         } else {
                                 ::memcpy(&(this->buffer[1][length]), &(iter->c_str()[offset]), iter->length() - offset);
 
                                 length += (iter->length() - offset);
                                 offset += (iter->length() - offset);
                         }
                 } while (offset != static_cast<ssize_t>(iter->length()));
         }
 
         /* Purge the buffer if required to make room for the record seperator. */
         if (sizeof(this->seperator) > (sizeof(this->buffer[1]) - length)) {
                 this->write(this->buffer[1], length, Z_NO_FLUSH);
 
                 length = 0;
         }
         this->buffer[1][length++] = this->seperator;
 
         this->write(this->buffer[1], length, Z_NO_FLUSH);
 }

void GZCSVFileWriter::write	(	uint8_t *	input,
		ssize_t	length,
		int	flush
	)

protected

Append a character sequence to the file after compressing it.

Parameters

[in]	data	The bytes to compress before writing.
[in]	size	The number of bytes to compress.
[in]	flush	The zlib flush flag to utilize for the compression.

Exceptions

IOException if unabled to write the supplied bytes for any reason.

Definition at line 124 of file GZCSVFileWriter.cpp.

                                                                                           {
         ssize_t expect;
 
         this->stream.next_in = input;
         this->stream.avail_in = length;
 
         do {
                 this->stream.next_out = this->buffer[0];
                 this->stream.avail_out = sizeof(this->buffer[0]);
 
                 /* Compress the supplied data into the buffer. */
                 switch (::deflate(&(this->stream), flush)) {
                         case Z_STREAM_ERROR:
                                 THROW(IOException, "zlib compression failure when writing buffer to compressed file '%s'", this->filename.c_str());
                 }
 
                 /* Write the compressed data to the file. */
                 if ((expect = (sizeof(this->buffer[0]) - this->stream.avail_out)) > 0) {
                         while ((length = ::write(this->descriptor, this->buffer[0], sizeof(this->buffer[0]) - this->stream.avail_out)) != expect) {
                                 if (length == -1) {
                                         THROW(IOException, "failure writing buffer to compressed file '%s'", this->filename.c_str());
                                 }
                                 expect -= length;
                         }
                 }
         } while (this->stream.avail_out == 0);
 
         /* Ensure all data was compressed and written to the file. */
         if (this->stream.avail_in != 0) {
                 THROW(IOException, "failed to write full buffer to compressed file '%s'", this->filename.c_str());
         }
 }

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

/home/sella/digitalgenesis/libutil++/releases/rpm/BUILD/libutil++-1.9.3/src/sella/file/GZCSVFileWriter.h
/home/sella/digitalgenesis/libutil++/releases/rpm/BUILD/libutil++-1.9.3/src/sella/file/GZCSVFileWriter.cpp

Public Member Functions

Static Public Attributes

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation