Disk ARchive  2.4.21
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 
44  {
45  none = 'n',
46  gzip = 'z',
47  bzip2 = 'y',
48  lzo = 'l'
49  };
50 
53 
54  extern compression char2compression(char a);
55  extern char compression2char(compression c);
56  extern std::string compression2string(compression c);
57  extern compression string2compression(const std::string & a); // throw Erange if an unknown string is given
58 
60  class compressor : public generic_file
61  {
62  public :
63  compressor(compression algo, generic_file & compressed_side, U_I compression_level = 9);
64  // compressed_side is not owned by the object and will remains
65  // after the objet destruction
66  compressor(compression algo, generic_file *compressed_side, U_I compression_level = 9);
67  // compressed_side is owned by the object and will be
68  // deleted a destructor time
69  ~compressor();
70 
71  void flush_write(); // flush all data to compressed_side, and reset the compressor
72  // for that additional write can be uncompresssed starting at this point.
73  void flush_read(); // reset decompression engine to be able to read the next block of compressed data
74  // if not called, furthur read return EOF
75  void clean_read(); // discard any byte buffered and not yet returned by read()
76  void clean_write(); // discard any byte buffered and not yet wrote to compressed_side;
77 
78  compression get_algo() const { return current_algo; };
79 
81 
86  void change_algo(compression new_algo, U_I new_compression_level);
87 
88 
90 
91  void change_algo(compression new_algo)
92  {
93  change_algo(new_algo, current_level);
94  };
95 
96  // inherited from generic file
97  bool skip(const infinint & pos) { flush_write(); flush_read(); clean_read(); return compressed->skip(pos); };
98  bool skip_to_eof() { flush_write(); flush_read(); clean_read(); return compressed->skip_to_eof(); };
99  bool skip_relative(S_I x) { flush_write(); flush_read(); clean_read(); return compressed->skip_relative(x); };
100  infinint get_position() { return compressed->get_position(); };
101 
102  protected :
103  U_I inherited_read(char *a, U_I size) { return (this->*read_ptr)(a, size); };
104  void inherited_write(const char *a, U_I size) { (this->*write_ptr)(a, size); };
105  void inherited_sync_write() { flush_write(); };
106  void inherited_terminate() { local_terminate(); };
107  private :
108  struct xfer
109  {
110  wrapperlib wrap;
111  char *buffer;
112  U_I size;
113 
114  xfer(U_I sz, wrapperlib_mode mode);
115  ~xfer();
116  };
117 
118  struct lzo_block_header
119  {
120  char type; //< let the possibility to extend this architecture (for now type is fixed)
121  infinint size; //< size of the following compressed block of data
122 
123  void dump(generic_file & f);
124  void set_from(generic_file & f);
125  };
126 
127 
128  xfer *compr, *decompr; //< datastructure for bzip2 an gzip compression
129 
130  char *lzo_read_buffer; //< stores clear data (uncompressed) read from the compressed generic_file
131  char *lzo_write_buffer; //< stores the clear data to be compressed and written to the compressed generic_file
132  U_I lzo_read_size; //< number of available bytes in the read buffer for lzo decompression
133  U_I lzo_write_size; //< number of available bytes to compress and next place where to add more data in the wite buffer
134  U_I lzo_read_start; //< location of the next byte to read out from the read buffer
135  bool lzo_write_flushed; //< whether write flushing has been done
136  bool lzo_read_reached_eof; //< whether reading reached end of file and the lzo engine has to be reset to uncompress further data
137  char *lzo_compressed; //< compressed data just read or about to be written
138  char *lzo_wrkmem; //< work memory for LZO library
139 
140  generic_file *compressed;
141  bool compressed_owner;
142  compression current_algo;
143  U_I current_level;
144 
145  void init(compression algo, generic_file *compressed_side, U_I compression_level);
146  void local_terminate();
147  U_I (compressor::*read_ptr) (char *a, U_I size);
148  U_I none_read(char *a, U_I size);
149  U_I gzip_read(char *a, U_I size);
150  // U_I zip_read(char *a, U_I size);
151  // U_I bzip2_read(char *a, U_I size); // using gzip_read, same code thanks to wrapperlib
152  U_I lzo_read(char *a, U_I size);
153 
154  void (compressor::*write_ptr) (const char *a, U_I size);
155  void none_write(const char *a, U_I size);
156  void gzip_write(const char *a, U_I size);
157  // void zip_write(char *a, U_I size);
158  // void bzip2_write(char *a, U_I size); // using gzip_write, same code thanks to wrapperlib
159  void lzo_write(const char *a, U_I size);
160 
161  void lzo_compress_buffer_and_write();
162  void lzo_read_and_uncompress_to_buffer();
163  };
164 
166 
167 } // end of namespace
168 
169 #endif
are defined here basic integer types that tend to be portable
void change_algo(compression new_algo)
changes the compression algorithm keeping the same compression level
Definition: compressor.hpp:91
class generic_file is defined here as well as class fichierthe generic_file interface is widely used ...
virtual bool skip(const infinint &pos)=0
skip at the absolute position
bzip2 compression
Definition: compressor.hpp:47
void inherited_terminate()
destructor-like call, except that it is allowed to throw exceptions
Definition: compressor.hpp:106
gzip compression
Definition: compressor.hpp:46
virtual bool skip_relative(S_I x)=0
skip relatively to the current position
no compression
Definition: compressor.hpp:45
bool skip_to_eof()
skip to the end of file
Definition: compressor.hpp:98
bool skip_relative(S_I x)
skip relatively to the current position
Definition: compressor.hpp:99
void inherited_sync_write()
write down any pending data
Definition: compressor.hpp:105
lzo compression
Definition: compressor.hpp:48
infinint get_position()
get the current read/write position
Definition: compressor.hpp:100
libz and libbz2 wrapper to have identical interface to these libraries.libz and libbz2 library differ...
this class encapsulates calls to libz or libbz2
Definition: wrapperlib.hpp:72
switch module to limitint (32 ou 64 bits integers) or infinint
compression class for gzip and bzip2 algorithms
Definition: compressor.hpp:60
compression
the different compression algorithm available
Definition: compressor.hpp:43
this is the interface class from which all other data transfer classes inherit
void inherited_write(const char *a, U_I size)
implementation of the write() operation
Definition: compressor.hpp:104
the arbitrary large positive integer class
bool skip(const infinint &pos)
skip at the absolute position
Definition: compressor.hpp:97
void change_algo(compression new_algo, U_I new_compression_level)
changes compression algorithm used by the compressor
virtual bool skip_to_eof()=0
skip to the end of file
virtual infinint get_position()=0
get the current read/write position
U_I inherited_read(char *a, U_I size)
implementation of read() operation
Definition: compressor.hpp:103
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:43