include/library/zip.hpp

   1 #ifndef _library__zip__hpp__included__
   2 #define _library__zip__hpp__included__
   3
   4 #include <boost/iostreams/filtering_stream.hpp>
   5 #include <iostream>
   6 #include <iterator>
   7 #include <string>
   8 #include <map>
   9 #include <fstream>
  10 #include <sstream>
  11 #include <zlib.h>
  12 #include "string.hpp"
  13
  14 namespace zip
  15 {
  16 /**
  17  * This class opens ZIP archive and offers methods to read members off it.
  18  */
  19 class reader
  20 {
  21 public:
  22 /**
  23  * This iterator iterates members of ZIP archive.
  24  */
  25         template<typename T, typename V>
  26         class iterator_class
  27         {
  28         public:
  29 /**
  30  * C++ iterators stuff.
  31  */
  32                 typedef std::bidirectional_iterator_tag iterator_category;
  33                 typedef V value_type;
  34                 typedef int difference_type;
  35                 typedef const V& reference;
  36                 typedef const V* pointer;
  37
  38 /**
  39  * This constructs new iteration sequence. Only the first component (keys) are taken into
  40  * account, the second component (values) are ignored.
  41  *
  42  * parameter _itr: The underlying map iterator.
  43  * throws std::bad_alloc: Not enough memory.
  44  */
  45                 iterator_class(T _itr)
  46                         : itr(_itr)
  47                 {
  48                 }
  49
  50 /**
  51  * Get name of current member.
  52  *
  53  * returns: Name of member.
  54  * throws std::bad_alloc: Not enough memory.
  55  */
  56                 reference operator*()
  57                 {
  58                         return itr->first;
  59                 }
  60
  61 /**
  62  * Get name of current member.
  63  *
  64  * returns: Name of member.
  65  * throws std::bad_alloc: Not enough memory.
  66  */
  67                 pointer operator->()
  68                 {
  69                         return &(itr->first);
  70                 }
  71
  72 /**
  73  * Are these two iterators the same?
  74  *
  75  * parameter i: The another iterator
  76  * returns: True if iterators are the same, false otherwise.
  77  */
  78                 bool operator==(const iterator_class<T, V>& i) const throw()
  79                 {
  80                         return itr == i.itr;
  81                 }
  82
  83 /**
  84  * Are these two iterators diffrent?
  85  *
  86  * paramer i: The another iterator
  87  * returns: True if iterators are diffrent, false otherwise.
  88  */
  89                 bool operator!=(const iterator_class<T, V>& i) const throw()
  90                 {
  91                         return itr != i.itr;
  92                 }
  93
  94 /**
  95  * Advance iterator one step.
  96  *
  97  * returns: The old value of iterator.
  98  * throws std::bad_alloc: Not enough memory.
  99  */
 100                 const iterator_class<T, V> operator++(int)
 101                 {
 102                         iterator_class<T, V> c(*this);
 103                         ++itr;
 104                         return c;
 105                 }
 106
 107 /**
 108  * Regress iterator one step.
 109  *
 110  * returns: The old value of iterator.
 111  * throws std::bad_alloc: Not enough memory.
 112  */
 113                 const iterator_class<T, V> operator--(int)
 114                 {
 115                         iterator_class<T, V> c(*this);
 116                         --itr;
 117                         return c;
 118                 }
 119
 120 /**
 121  * Advance iterator one step.
 122  *
 123  * returns: Reference to this iterator.
 124  */
 125                 iterator_class<T, V>& operator++() throw()
 126                 {
 127                         ++itr;
 128                         return *this;
 129                 }
 130
 131 /**
 132  * Regress iterator one step.
 133  *
 134  * returns: Reference to this iterator.
 135  */
 136                 iterator_class<T, V>& operator--() throw()
 137                 {
 138                         --itr;
 139                         return *this;
 140                 }
 141         private:
 142                 T itr;
 143         };
 144
 145 /**
 146  * This iterator iterates members of ZIP archive in forward order.
 147  */
 148         typedef iterator_class<std::map<std::string, uint64_t>::iterator, std::string> iterator;
 149
 150 /**
 151  * This iterator iterates members of ZIP archive in reverse order
 152  */
 153         typedef iterator_class<std::map<std::string, uint64_t>::reverse_iterator, std::string>
 154                 riterator;
 155
 156 /**
 157  * Opens specified ZIP archive for reading.
 158  *
 159  * parameter zipfile: The name of ZIP file to open.
 160  * throws std::bad_alloc: Not enough memory.
 161  * throws std::runtime_error: Can't open the ZIP file.
 162  */
 163         reader(const std::string& zipfile);
 164
 165 /**
 166  * Destroy the ZIP reader. Opened input streams continue to be valid.
 167  */
 168         ~reader() throw();
 169
 170 /**
 171  * Gives the name of the first member, or "" if empty archive.
 172  *
 173  * returns: The member name
 174  * throws std::bad_alloc: Not enough memory.
 175  */
 176         std::string find_first();
 177
 178 /**
 179  * Gives the name of the next member after specified, or "" if that member is the last.
 180  *
 181  * parameter name: The name to start the search from.
 182  * returns: The member name
 183  * throws std::bad_alloc: Not enough memory.
 184  */
 185         std::string find_next(const std::string& name);
 186
 187 /**
 188  * Starting iterator
 189  *
 190  * returns: The iterator pointing to first name.
 191  * throws std::bad_alloc: Not enough memory.
 192  */
 193         iterator begin();
 194
 195 /**
 196  * Ending iterator (one past the end).
 197  *
 198  * returns: The iterator pointing to one past the last name.
 199  * throws std::bad_alloc: Not enough memory.
 200  */
 201         iterator end();
 202
 203 /**
 204  * Starting reverse iterator
 205  *
 206  * returns: The iterator pointing to last name and acting in reverse.
 207  * throws std::bad_alloc: Not enough memory.
 208  */
 209         riterator rbegin();
 210
 211 /**
 212  * Ending reverse iterator (one past the start).
 213  * returrns: The iterator pointing to one before the first name and acting in reverse.
 214  * throws std::bad_alloc: Not enough memory.
 215  */
 216         riterator rend();
 217
 218 /**
 219  * Check if member with specified name exists.
 220  *
 221  * parameter name: The name of the member to check
 222  * returns: True if specified member exists, false otherwise.
 223  */
 224         bool has_member(const std::string& name) throw();
 225
 226 /**
 227  * Opens specified member. The resulting stream is not seekable, allocated using new and continues to be valid
 228  * after ZIP reader has been destroyed.
 229  *
 230  * parameter name: The name of member to open.
 231  * returns: The stream corresponding to member.
 232  * throws std::bad_alloc: Not enough memory.
 233  * throws std::runtime_error: The specified member does not exist
 234  */
 235         std::istream& operator[](const std::string& name);
 236 /**
 237  * Reads a file consisting of single line.
 238  *
 239  * Parameter member: Name of the member to read.
 240  * Parameter out: String to write the output to.
 241  * Parameter conditional: If true and the file does not exist, return false instead of throwing.
 242  * Returns: True on success, false on failure.
 243  * Throws std::bad_alloc: Not enough memory.
 244  * Throws std::runtime_error: Error reading file.
 245  */
 246         bool read_linefile(const std::string& member, std::string& out, bool conditional = false);
 247 /**
 248  * Read a raw file.
 249  *
 250  * Parameter member: Name of the member to read.
 251  * Parameter out: Buffer to write the output to.
 252  * Throws std::bad_alloc: Not enough memory.
 253  * Throws std::runtime_error: Error reading file.
 254  */
 255         void read_raw_file(const std::string& member, std::vector<char>& out);
 256 /**
 257  * Reads a file consisting of single numeric constant.
 258  *
 259  * Parameter member: Name of the member to read.
 260  * Parameter out: The output value.
 261  * Parameter conditional: If true and the file does not exist, return false instead of throwing.
 262  * Returns: True on success, false on failure.
 263  * Throws std::bad_alloc: Not enough memory.
 264  * Throws std::runtime_error: Error reading file.
 265  */
 266         template<typename T>
 267         bool read_numeric_file(const std::string& member, T& out, bool conditional = false)
 268         {
 269                 std::string _out;
 270                 if(!read_linefile(member, _out, conditional))
 271                         return false;
 272                 out = parse_value<T>(_out);
 273                 return true;
 274         }
 275 private:
 276         reader(reader&);
 277         reader& operator=(reader&);
 278         std::map<std::string, uint64_t> offsets;
 279         std::ifstream* zipstream;
 280         size_t* refcnt;
 281 };
 282
 283 /**
 284  * Opens the file named by name parameter, which is interpretted relative to file designated by referencing_path.
 285  * The file can be inside ZIP archive. The resulting stream may or may not be seekable.
 286  *
 287  * If referencing_path is "", then name is traditional relative/absolute path. Otherwise if name is relative,
 288  * it is relative to directory containing referencing_path, not current directory.
 289  *
 290  * parameter name: The name of file to open.
 291  * parameter referencing_path: The path to file name is interpretted against.
 292  * returns: The new stream, allocated by new.
 293  * throw std::bad_alloc: Not enough memory.
 294  * throw std::runtime_error: The file does not exist or can't be opened.
 295  */
 296 std::istream& openrel(const std::string& name, const std::string& referencing_path);
 297
 298 /**
 299  * As zip::openrel, but instead of returning handle to file, reads the entiere contents of the file and returns
 300  * that.
 301  *
 302  * parameter name: As in zip::openrel
 303  * parameter referencing_path: As in zip::openrel.
 304  * returns: The file contents.
 305  * throws std::bad_alloc: Not enough memory.
 306  * throws std::runtime_error: The file does not exist or can't be opened.
 307  */
 308 std::vector<char> readrel(const std::string& name, const std::string& referencing_path);
 309
 310 /**
 311  * Resolves the final file path that zip::openrel/zip::readrel would open.
 312  *
 313  * parameter name: As in zip::openrel
 314  * parameter referencing_path: As in zip::openrel
 315  * returns: The file absolute path.
 316  * throws std::bad_alloc: Not enough memory.
 317  * throws std::runtime_error: Bad path.
 318  */
 319 std::string resolverel(const std::string& name, const std::string& referencing_path);
 320
 321 /**
 322  * Does the specified file (maybe inside .zip) exist?
 323  *
 324  * parameter name: The name of file.
 325  * returns: True if file exists, false if not.
 326  * throws std::bad_alloc: Not enough memory.
 327  */
 328 bool file_exists(const std::string& name);
 329
 330 /**
 331  * This class handles writing a ZIP archives.
 332  */
 333 class writer
 334 {
 335 public:
 336 /**
 337  * Creates new empty ZIP archive. The members will be compressed according to specified compression.
 338  *
 339  * parameter zipfile: The zipfile to create.
 340  * parameter stream: The stream to write the ZIP to.
 341  * parameter _compression: Compression. 0 is uncompressed, 1-9 are deflate compression levels.
 342  * throws std::bad_alloc: Not enough memory.
 343  * throws std::runtime_error: Can't open archive or invalid argument.
 344  */
 345         writer(const std::string& zipfile, unsigned _compression);
 346         writer(std::ostream& stream, unsigned _compression);
 347 /**
 348  * Destroys ZIP writer, aborting the transaction (unless commit() has been called).
 349  */
 350         ~writer() throw();
 351
 352 /**
 353  * Commits the ZIP file. Does atomic replace of existing file if possible.
 354  *
 355  * throws std::bad_alloc: Not enough memory.
 356  * throws std::logic_error: Existing file open.
 357  * throws std::runtime_error: Can't commit archive (OS error or member open).
 358  */
 359         void commit();
 360
 361 /**
 362  * Create a new member inside ZIP file. No existing member may be open.
 363  *
 364  * parameter name: The name for new member.
 365  * returns: Writing stream for the file (don't free).
 366  * throws std::bad_alloc: Not enough memory.
 367  * throws std::logic_error: Existing file open.
 368  * throws std::runtime_error: Illegal name.
 369  */
 370         std::ostream& create_file(const std::string& name);
 371
 372 /**
 373  * Closes open member and destroys stream corresponding to it.
 374  *
 375  * throws std::bad_alloc: Not enough memory.
 376  * throws std::logic_error: No file open.
 377  * throws std::runtime_error: Error from operating system.
 378  */
 379         void close_file();
 380 /**
 381  * Write a file consisting of single line. No existing member may be open.
 382  *
 383  * Parameter member: The name of the member.
 384  * Parameter value: The value to write.
 385  * Parameter conditional: If true and the value is empty, skip the write.
 386  * throws std::bad_alloc: Not enough memory.
 387  * throws std::runtime_error: Error from operating system.
 388  */
 389         void write_linefile(const std::string& member, const std::string& value, bool conditional = false);
 390 /**
 391  * Write a raw file. No existing member may be open.
 392  *
 393  * Parameter member: The name of the member.
 394  * Parameter content: The contents for the file.
 395  * throws std::bad_alloc: Not enough memory.
 396  * throws std::runtime_error: Error from operating system.
 397  */
 398         void write_raw_file(const std::string& member, const std::vector<char>& content);
 399 /**
 400  * Write a file consisting of a single number. No existing member may be open.
 401  *
 402  * Parameter member: The name of the member.
 403  * Parameter value: The value to write.
 404  * throws std::bad_alloc: Not enough memory.
 405  * throws std::runtime_error: Error from operating system.
 406  */
 407         template<typename T>
 408         void write_numeric_file(const std::string& member, T value)
 409         {
 410                 write_linefile(member, (stringfmt() << value).str());
 411         }
 412 private:
 413         struct file_info
 414         {
 415                 uint32_t crc;
 416                 uint32_t uncompressed_size;
 417                 uint32_t compressed_size;
 418                 uint32_t offset;
 419         };
 420
 421         writer(writer&);
 422         writer& operator=(writer&);
 423         std::ostream* zipstream;
 424         bool system_stream;
 425         std::string temp_path;
 426         std::string zipfile_path;
 427         std::string open_file;
 428         uint32_t base_offset;
 429         std::vector<char> current_compressed_file;
 430         std::map<std::string, file_info> files;
 431         unsigned compression;
 432         boost::iostreams::filtering_ostream* s;
 433         uint32_t basepos;
 434         bool committed;
 435 };
 436 }
 437 #endif