sella::file::GZCSVFileWriter Class Reference

#include <GZCSVFileWriter.h>

List of all members.

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 24 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 51 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 163 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	(	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 122 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());
        }
}

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 66 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);
}

---

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

• /builddir/build/BUILD/libutil++-1.4.0/src/sella/file/GZCSVFileWriter.h
• /builddir/build/BUILD/libutil++-1.4.0/src/sella/file/GZCSVFileWriter.cpp