| Disk ARchive 2.5.10 Full featured and portable backup and archiving tool

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

compressor.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2052 Denis Corbin
4 //
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 2
8 // of the License, or (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 //
19 // to contact the author : http://dar.linux.free.fr/email.html
20 /*********************************************************************/
21
25
26 #ifndef COMPRESSOR_HPP
27 #define COMPRESSOR_HPP
28
29 #include "../my_config.h"
30
31 #include "infinint.hpp"
32 #include "generic_file.hpp"
33 #include "integers.hpp"
34 #include "wrapperlib.hpp"
35
36 namespace libdar
37 {
38
40
43 enum compression
44 {
45 none = 'n',
46 gzip = 'z',
47 bzip2 = 'y',
48 lzo = 'l',
49 xz = 'x',
50 lzo1x_1_15 = 'j',
51 lzo1x_1 = 'k'
52 };
57
60
61 extern compression char2compression(char a);
62 extern char compression2char(compression c);
63 extern std::string compression2string(compression c);
64 extern compression string2compression(const std::string & a); // throw Erange if an unknown string is given
65
67 class compressor : public generic_file
68 {
69 public :
70 compressor(compression algo, generic_file & compressed_side, U_I compression_level = 9);
71 // compressed_side is not owned by the object and will remains
72 // after the objet destruction
73 compressor(compression algo, generic_file *compressed_side, U_I compression_level = 9);
74 // compressed_side is owned by the object and will be
75 // deleted a destructor time
76 ~compressor();
77
78 compression get_algo() const { return (current_algo == lzo1x_1_15 || current_algo == lzo1x_1) ? lzo : current_algo; };
79
80 void suspend_compression();
81 void resume_compression();
82 bool is_compression_suspended() const { return suspended; };
83
84
85 // inherited from generic file
86 bool skippable(skippability direction, const infinint & amount) { return compressed->skippable(direction, amount); };
87 bool skip(const infinint & pos) { compr_flush_write(); compr_flush_read(); clean_read(); return compressed->skip(pos); };
88 bool skip_to_eof() { compr_flush_write(); compr_flush_read(); clean_read(); return compressed->skip_to_eof(); };
89 bool skip_relative(S_I x) { compr_flush_write(); compr_flush_read(); clean_read(); return compressed->skip_relative(x); };
90 infinint get_position() const { return compressed->get_position(); };
91
92 protected :
93 void inherited_read_ahead(const infinint & amount) { compressed->read_ahead(amount); };
94 U_I inherited_read(char *a, U_I size) { return (this->*read_ptr)(a, size); };
95 void inherited_write(const char *a, U_I size) { (this->*write_ptr)(a, size); };
96 void inherited_sync_write() { compr_flush_write(); };
97 void inherited_flush_read() { compr_flush_read(); clean_read(); };
98 void inherited_terminate() { local_terminate(); };
99
100 private :
101 struct xfer : public on_pool
102 {
103 wrapperlib wrap;
104 char *buffer;
105 U_I size;
106
107 xfer(U_I sz, wrapperlib_mode mode);
108 ~xfer();
109 };
110
111 struct lzo_block_header
112 {
113 char type; //< let the possibility to extend this architecture (for now type is fixed)
114 infinint size; //< size of the following compressed block of data
115
116 void dump(generic_file & f);
117 void set_from(generic_file & f);
118 };
119
120
121 xfer *compr, *decompr; //< datastructure for bzip2 an gzip compression
122
123 char *lzo_read_buffer; //< stores clear data (uncompressed) read from the compressed generic_file
124 char *lzo_write_buffer; //< stores the clear data to be compressed and written to the compressed generic_file
125 U_I lzo_read_size; //< number of available bytes in the read buffer for lzo decompression
126 U_I lzo_write_size; //< number of available bytes to compress and next place where to add more data in the wite buffer
127 U_I lzo_read_start; //< location of the next byte to read out from the read buffer
128 bool lzo_write_flushed; //< whether write flushing has been done
129 bool lzo_read_reached_eof; //< whether reading reached end of file and the lzo engine has to be reset to uncompress further data
130 char *lzo_compressed; //< compressed data just read or about to be written
131 char *lzo_wrkmem; //< work memory for LZO library
132
133 generic_file *compressed;
134 bool compressed_owner;
135 compression current_algo;
136 bool suspended;
137 compression suspended_compr;
138 U_I current_level;
139
140 void init(compression algo, generic_file *compressed_side, U_I compression_level);
141 void local_terminate();
142 U_I (compressor::*read_ptr) (char *a, U_I size);
143 U_I none_read(char *a, U_I size);
144 U_I gzip_read(char *a, U_I size);
145 // U_I zip_read(char *a, U_I size);
146 // U_I bzip2_read(char *a, U_I size); // using gzip_read, same code thanks to wrapperlib
147 U_I lzo_read(char *a, U_I size);
148
149 void (compressor::*write_ptr) (const char *a, U_I size);
150 void none_write(const char *a, U_I size);
151 void gzip_write(const char *a, U_I size);
152 // void zip_write(char *a, U_I size);
153 // void bzip2_write(char *a, U_I size); // using gzip_write, same code thanks to wrapperlib
154 void lzo_write(const char *a, U_I size);
155
156 void lzo_compress_buffer_and_write();
157 void lzo_read_and_uncompress_to_buffer();
158
160
165 void change_algo(compression new_algo, U_I new_compression_level);
166
167
169
170 void change_algo(compression new_algo)
171 { change_algo(new_algo, current_level); };
172
173
174 void compr_flush_write(); // flush all data to compressed_side, and reset the compressor
175 // for that additional write can be uncompresssed starting at this point.
176 void compr_flush_read(); // reset decompression engine to be able to read the next block of compressed data
177 // if not called, furthur read return EOF
178 void clean_read(); // discard any byte buffered and not yet returned by read()
179 void clean_write(); // discard any byte buffered and not yet wrote to compressed_side;
180 };
181
183
184 } // end of namespace
185
186 #endif
libdar::on_pool
Definition: on_pool.hpp:52
libdar::compressor::inherited_flush_read
void inherited_flush_read()
Definition: compressor.hpp:97
libdar::lzo1x_1_15
lzo degraded algo corresponding to lzop -1
Definition: compressor.hpp:50
integers.hpp
are defined here basic integer types that tend to be portable
libdar::compressor::inherited_read_ahead
void inherited_read_ahead(const infinint &amount)
Definition: compressor.hpp:93
libdar::xz
lzma compression
Definition: compressor.hpp:49
generic_file.hpp
class generic_file is defined here as well as class fichierthe generic_file interface is widely used ...
libdar::generic_file::get_position
virtual infinint get_position() const =0
get the current read/write position
libdar::generic_file::skip
virtual bool skip(const infinint &pos)=0
libdar::generic_file::read_ahead
virtual void read_ahead(const infinint &amount)
libdar::bzip2
bzip2 compression
Definition: compressor.hpp:47
libdar::compressor::inherited_terminate
void inherited_terminate()
destructor-like call, except that it is allowed to throw exceptions
Definition: compressor.hpp:98
libdar::gzip
gzip compression
Definition: compressor.hpp:46
libdar::generic_file::skip_relative
virtual bool skip_relative(S_I x)=0
skip relatively to the current position
libdar::none
no compression
Definition: compressor.hpp:45
libdar::compressor::skip_to_eof
bool skip_to_eof()
skip to the end of file
Definition: compressor.hpp:88
libdar::compressor::skip_relative
bool skip_relative(S_I x)
skip relatively to the current position
Definition: compressor.hpp:89
libdar::compressor::inherited_sync_write
void inherited_sync_write()
write down any pending data
Definition: compressor.hpp:96
libdar::lzo
lzo compression
Definition: compressor.hpp:48
libdar::generic_file::generic_file
generic_file(gf_mode m)
main constructor
Definition: generic_file.hpp:104
wrapperlib.hpp
libz and libbz2 wrapper to have identical interface to these libraries.libz and libbz2 library differ...
libdar::wrapperlib
this class encapsulates calls to libz or libbz2
Definition: wrapperlib.hpp:77
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
libdar::compressor
compression class for gzip and bzip2 algorithms
Definition: compressor.hpp:67
libdar::compression
compression
the different compression algorithm available
Definition: compressor.hpp:43
libdar::generic_file
this is the interface class from which all other data transfer classes inherit
Definition: generic_file.hpp:100
libdar::lzo1x_1
lzo degraded algo corresponding to lzo -2 to lzo -6
Definition: compressor.hpp:51
libdar::compressor::get_position
infinint get_position() const
get the current read/write position
Definition: compressor.hpp:90
libdar::compressor::inherited_write
void inherited_write(const char *a, U_I size)
implementation of the write() operation
Definition: compressor.hpp:95
libdar::infinint
the arbitrary large positive integer class
Definition: real_infinint.hpp:59
libdar::compressor::skip
bool skip(const infinint &pos)
Definition: compressor.hpp:87
libdar::generic_file::skip_to_eof
virtual bool skip_to_eof()=0
skip to the end of file
libdar::compressor::inherited_read
U_I inherited_read(char *a, U_I size)
implementation of read() operation
Definition: compressor.hpp:94
libdar::compressor::skippable
bool skippable(skippability direction, const infinint &amount)
Definition: compressor.hpp:86
libdar::char2compression
compression char2compression(char a)
libdar
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47
libdar::generic_file::skippable
virtual bool skippable(skippability direction, const infinint &amount)=0