zlib将数据直接写为gz压缩文件

zlib写gz压缩文件，头文件ma_gzfile_op.h:

////////////////////////////////////////////////////////////////
//
//Descript: gzfile option.
// Author: guowenyan
// Date: 2013.07.01
//
////////////////////////////////////////////////////////////////
#pragma once

#include <string>
#include <zlib.h>

class CMaGzFileOp
{
public:
CMaGzFileOp(std::string file_name, std::string open_mode);
~CMaGzFileOp();

public:
bool open_file();
bool seek_file(long offset, int origin);
bool write_file(const char *buf, int len);
void close_file();

private:
bool is_gz_file();

public:
std::string m_file_name;
std::string m_open_mode;
gzFile m_gz_fp;
};

zlib写gz压缩文件，实现文件ma_gzfile_op.cpp:
////////////////////////////////////////////////////////////////
//
//Descript: gzfile option.
// Author: guowenyan
// Date: 2013.07.01
//
////////////////////////////////////////////////////////////////
#include "ma_gzfile_op.h"
#include "ma_dir_op.h"
#include "ma_type.h"

using namespace std;

CMaGzFileOp::CMaGzFileOp(string file_name, string open_mode) : m_file_name(file_name), m_open_mode(open_mode), m_gz_fp(NULL)
{

}

CMaGzFileOp::~CMaGzFileOp()
{
close_file();
}

bool CMaGzFileOp::open_file()
{
if(NULL == m_gz_fp)
m_gz_fp = gzopen(m_file_name.c_str(),m_open_mode.c_str());

return NULL != m_gz_fp;
}

bool CMaGzFileOp::seek_file(long offset, int origin)
{
if(NULL == m_gz_fp)
return false;

return -1 != gzseek(m_gz_fp, offset, origin);
}

bool CMaGzFileOp::write_file(const char *buf, int len)
{
if(NULL == m_gz_fp)
return false;

return gzwrite(m_gz_fp, buf, len) == len;
}

void CMaGzFileOp::close_file()
{
if(m_gz_fp)
{
gzclose(m_gz_fp);
m_gz_fp = NULL;
}
}

bool CMaGzFileOp::is_gz_file()
{
CMaDirOperation *p_dir_op = CMaDirOperation::get_instance();
if(p_dir_op)
return p_dir_op->is_file_type(m_file_name, MA_FILE_TYPE_GZ);

return false;
}
zlib缓存写gz压缩文件，头文件ma_gzfile_buf.h:
////////////////////////////////////////////////////////////////
//
//Descript: gzfile option with buf when write.
// Author: guowenyan
// Date: 2013.07.02
//
////////////////////////////////////////////////////////////////
#pragma once
#include <string.h>
#include "ma_gzfile_op.h"

class CMaGzfileBuf
{
public:
CMaGzfileBuf(std::string file_name, std::string open_mode);
~CMaGzfileBuf();

public:
bool open_file();
bool seek_file(long offset, int origin);
bool write_file(const char *buf, int len);
bool write_file_with_buf(const char *buf, int len);
void close_file();

private:
void new_read_buf();
void delete_read_buf();

bool write_buf();

private:
std::string m_file_name;
std::string m_open_mode;

CMaGzFileOp m_gzfile_op;

char *m_p_write_buf;
long m_write_buf_len;
};
zlib缓存写gz压缩文件，实现文件ma_gzfile_buf.cpp:

////////////////////////////////////////////////////////////////
//
//Descript: gzfile option with buf when write.
// Author: guowenyan
// Date: 2013.07.02
//
////////////////////////////////////////////////////////////////
#include "ma_gzfile_buf.h"
#include "ma_type.h"

#include <iostream>

using namespace std;

CMaGzfileBuf::CMaGzfileBuf(string file_name, string open_mode) : m_file_name(file_name), m_open_mode(open_mode), m_gzfile_op(m_file_name, m_open_mode),
m_p_write_buf(NULL), m_write_buf_len(0)
{

}

CMaGzfileBuf::~CMaGzfileBuf()
{
close_file();
delete_read_buf();
}

bool CMaGzfileBuf::open_file()
{
return m_gzfile_op.open_file();
}

bool CMaGzfileBuf::seek_file(long offset, int origin)
{
return m_gzfile_op.seek_file(offset, origin);
}

bool CMaGzfileBuf::write_file(const char *buf, int len)
{
return m_gzfile_op.write_file(buf, len);
}

bool CMaGzfileBuf::write_file_with_buf(const char *buf, int len)
{
if(len <= 0)
return false;

if((NULL == m_p_write_buf) && (0 == m_write_buf_len))
{
new_read_buf();
}

if(NULL != m_p_write_buf)
{
bool b_write = true;
if(len >= MA_WRITE_FILE_BUF_LEN)
{
b_write = write_buf();
return b_write && write_file(buf, len);
}

if(m_write_buf_len + len > MA_WRITE_FILE_BUF_LEN)
{
b_write = write_buf();
}

strncpy(m_p_write_buf+m_write_buf_len, buf, len);
m_write_buf_len += len;

return b_write;
}

return write_file(buf, len);
}

void CMaGzfileBuf::close_file()
{
write_buf();
return m_gzfile_op.close_file();
}

void CMaGzfileBuf::new_read_buf()
{
if(NULL == m_p_write_buf)
{
m_p_write_buf = new(nothrow) char[MA_WRITE_FILE_BUF_LEN + 1];
if(NULL == m_p_write_buf)
{
cout<<"Fail to new write buf in CMaGzfileBuf::new_read_buf()"<<endl;
}
}
}

void CMaGzfileBuf::delete_read_buf()
{
if(m_p_write_buf)
{
delete []m_p_write_buf;
m_p_write_buf = NULL;
}
}

bool CMaGzfileBuf::write_buf()
{
if((NULL != m_p_write_buf) && (0 != m_write_buf_len))
{
bool b_write = write_file(m_p_write_buf, m_write_buf_len);
if(b_write)
{
m_write_buf_len = 0;
}

return b_write;
}

return true;
}