ZIP Compression works!
authorMichael McMaster <email@michaelmcmaster.name>
Thu, 19 May 2011 11:41:56 +0000 (21:41 +1000)
committerMichael McMaster <email@michaelmcmaster.name>
Thu, 19 May 2011 11:41:56 +0000 (21:41 +1000)
24 files changed:
Compressor.cc [new file with mode: 0644]
Consumer.cc [deleted file]
Container.cc [new file with mode: 0644]
Decompressor.cc [new file with mode: 0644]
Doxyfile.in [new file with mode: 0644]
Exception.cc
FileReader.cc [new file with mode: 0644]
FileWriter.cc [new file with mode: 0644]
Makefile.am
Provider.cc [deleted file]
README
Reader.cc [new file with mode: 0644]
Ungzip.cc [new file with mode: 0644]
Ungzip.hh [new file with mode: 0644]
Unzip.cc
Unzip.hh [new file with mode: 0644]
Writer.cc [new file with mode: 0644]
Zip.cc [new file with mode: 0644]
Zip.hh [new file with mode: 0644]
configure.ac
doxygen.am [new file with mode: 0644]
util.hh [new file with mode: 0644]
zipper.cc
zipper.hh

diff --git a/Compressor.cc b/Compressor.cc
new file mode 100644 (file)
index 0000000..456385f
--- /dev/null
@@ -0,0 +1,139 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+#include "Zip.hh"
+#include "util.hh"
+
+#include <algorithm>
+
+#include <zlib.h>
+
+using namespace zipper;
+
+class Compressor::CompressorImpl
+{
+public:
+       virtual ~CompressorImpl() {}
+
+       virtual void
+       addFile(const std::string& filename, const Reader& reader) = 0;
+};
+
+namespace
+{
+       class PlainCompressor : public Compressor::CompressorImpl
+       {
+       public:
+               PlainCompressor(const WriterPtr& writer) : m_writer(writer) {}
+
+               virtual void
+               addFile(const std::string&, const Reader& reader)
+               {
+                       enum Constants
+                       {
+                               ChunkSize = 64*1024
+                       };
+
+                       uint8_t buffer[ChunkSize];
+                       zsize_t offset(0);
+                       while (offset < reader.getSize())
+                       {
+                               zsize_t bytes(
+                                       std::min(zsize_t(ChunkSize), reader.getSize() - offset));
+                               reader.readData(offset, bytes, &buffer[0]);
+                               m_writer->writeData(offset, bytes, &buffer[0]);
+                               offset += bytes;
+                       }
+               }
+       private:
+               WriterPtr m_writer;
+       };
+
+       class ZipCompressor : public Compressor::CompressorImpl
+       {
+       public:
+               ZipCompressor(const WriterPtr& writer) : m_writer(writer) {}
+
+               virtual ~ZipCompressor()
+               {
+                       zipFinalise(m_records, m_writer);
+               }
+
+               virtual void
+               addFile(const std::string& filename, const Reader& reader)
+               {
+                       ZipFileRecord record;
+                       zip(filename, reader, m_writer, record);
+                       m_records.push_back(record);
+               }
+       private:
+               WriterPtr m_writer;
+               std::vector<ZipFileRecord> m_records;
+       };
+}
+
+Compressor::Compressor(ContainerFormat format, const WriterPtr& writer)
+{
+       switch (format)
+       {
+       case Container_none:
+               m_compressor = new PlainCompressor(writer); break;
+
+       case Container_zip:
+               m_compressor = new ZipCompressor(writer); break;
+
+       //case Container_none:
+       //      m_compressor = new GzipCompressor(writer); break;
+
+       default:
+               throw UnsupportedException("Unknown format");
+       }
+}
+
+Compressor::Compressor(ContainerFormat format, Writer& writer) :
+       m_compressor(NULL)
+{
+       WriterPtr ptr(&writer, dummy_delete<Writer>());
+       switch (format)
+       {
+       case Container_none:
+               m_compressor = new PlainCompressor(ptr); break;
+
+       case Container_zip:
+               m_compressor = new ZipCompressor(ptr); break;
+
+       //case Container_none:
+       //      m_compressor = new GzipCompressor(ptr); break;
+
+       default:
+               throw UnsupportedException("Unknown format");
+       }
+}
+
+Compressor::~Compressor()
+{
+       delete m_compressor;
+}
+
+void
+Compressor::addFile(const Reader& reader)
+{
+       m_compressor->addFile(reader.getSourceName(), reader);
+}
+
+
diff --git a/Consumer.cc b/Consumer.cc
deleted file mode 100644 (file)
index fd102b8..0000000
+++ /dev/null
@@ -1,25 +0,0 @@
-//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
-//
-//     This file is part of libzipper.
-//
-//     libzipper is free software: you can redistribute it and/or modify
-//     it under the terms of the GNU General Public License as published by
-//     the Free Software Foundation, either version 3 of the License, or
-//     (at your option) any later version.
-//
-//     libzipper is distributed in the hope that it will be useful,
-//     but WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//     GNU General Public License for more details.
-//
-//     You should have received a copy of the GNU General Public License
-//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "zipper.hh"
-
-using namespace zipper;
-
-Consumer::~Consumer()
-{
-}
-
diff --git a/Container.cc b/Container.cc
new file mode 100644 (file)
index 0000000..273f6d2
--- /dev/null
@@ -0,0 +1,47 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+
+using namespace zipper;
+
+namespace
+{
+       struct Container info_none =
+               { Container_none, "application/octet-stream", 13 };
+       struct Container info_zip =
+               { Container_zip, "application/zip", 0x1f };
+       struct Container info_gzip =
+               { Container_gzip, "zpplication/x-gzip", 7 };
+}
+
+namespace zipper
+{
+       const Container&
+       getContainer(ContainerFormat format)
+       {
+               switch (format)
+               {
+               case Container_none: return info_none;
+               case Container_zip: return info_zip;
+               case Container_gzip: return info_gzip;
+               default: throw Exception("Unknown format type requested");
+               }
+
+       }
+}
+
diff --git a/Decompressor.cc b/Decompressor.cc
new file mode 100644 (file)
index 0000000..e51f9a6
--- /dev/null
@@ -0,0 +1,137 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+#include "util.hh"
+
+#include "Unzip.hh"
+#include "Ungzip.hh"
+
+using namespace zipper;
+
+namespace
+{
+       class PlainFile : public CompressedFile
+       {
+       public:
+               PlainFile(const ReaderPtr& reader) :
+                       m_reader(reader)
+               {}
+
+               virtual bool isDecompressSupported() const { return true; }
+               virtual const std::string& getPath() const
+               {
+                       return m_reader->getSourceName();
+               }
+               virtual zsize_t getCompressedSize() const
+               {
+                       return m_reader->getSize();
+               }
+               virtual zsize_t getUncompressedSize() const
+               {
+                       return m_reader->getSize();
+               }
+
+               virtual void decompress(Writer& writer)
+               {
+                       enum Constants
+                       {
+                               ChunkSize = 64*1024
+                       };
+                       zsize_t end(m_reader->getSize());
+
+                       for (zsize_t pos(0); pos < end; pos += ChunkSize)
+                       {
+                               uint8_t buf[ChunkSize];
+                               size_t bytes(
+                                       std::min(zsize_t(ChunkSize), end - pos)
+                                       );
+                               m_reader->readData(pos, bytes, &buf[0]);
+                               writer.writeData(pos, bytes, &buf[0]);
+                       }
+               }
+
+       private:
+               ReaderPtr m_reader;
+       };
+}
+
+class Decompressor::DecompressorImpl
+{
+public:
+       DecompressorImpl(const ReaderPtr& reader) :
+               m_reader(reader),
+               m_format(Container_none)
+       {
+               if (isZip(reader))
+               {
+                       m_format = Container_zip;
+                       m_entries = unzip(reader);
+               }
+               else if (isGzip(reader))
+               {
+                       m_format = Container_gzip;
+                       m_entries = ungzip(reader);
+               }
+               else
+               {
+                       m_format = Container_none;
+                       m_entries.push_back(
+                               CompressedFilePtr(new PlainFile(reader))
+                               );
+               }
+       }
+
+       ContainerFormat getContainerFormat() const { return m_format; }
+
+       std::vector<CompressedFilePtr> getEntries() const { return m_entries; }
+
+private:
+       ReaderPtr m_reader;
+       ContainerFormat m_format;
+       std::vector<CompressedFilePtr> m_entries;
+};
+
+Decompressor::Decompressor(const ReaderPtr& reader) :
+       m_decompressor(new DecompressorImpl(reader))
+{
+}
+
+Decompressor::Decompressor(Reader& reader) :
+       m_decompressor(
+               new DecompressorImpl(ReaderPtr(&reader, dummy_delete<Reader>()))
+               )
+{
+}
+
+Decompressor::~Decompressor()
+{
+       delete m_decompressor;
+}
+
+ContainerFormat
+Decompressor::getContainerFormat() const
+{
+       return m_decompressor->getContainerFormat();
+}
+
+std::vector<CompressedFilePtr>
+Decompressor::getEntries() const
+{
+       return m_decompressor->getEntries();
+}
+
diff --git a/Doxyfile.in b/Doxyfile.in
new file mode 100644 (file)
index 0000000..6fc4093
--- /dev/null
@@ -0,0 +1,1661 @@
+# Doxyfile 1.7.1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file 
+# that follow. The default is UTF-8 which is also the encoding used for all 
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the 
+# iconv built into libc) for the transcoding. See 
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = libzipper
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = @libzipper_version@
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = doc
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
+# 4096 sub-directories (in 2 levels) under the output directory of each output 
+# format and will distribute the generated files over these directories. 
+# Enabling this option can be useful when feeding doxygen a huge amount of 
+# source files, where putting all generated files in the same directory would 
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, 
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, 
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English 
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, 
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, 
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator 
+# that is used to form the text in various listings. Each string 
+# in this list, if found as the leading text of the brief description, will be 
+# stripped from the text and the result after processing the whole list, is 
+# used as the annotated text. Otherwise, the brief description is used as-is. 
+# If left blank, the following values are used ("$name" is automatically 
+# replaced with the name of the entity): "The $name class" "The $name widget" 
+# "The $name file" "is" "provides" "specifies" "contains" 
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all 
+# inherited members of a class in the documentation of that class as if those 
+# members were ordinary class members. Constructors, destructors and assignment 
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
+# the path mentioned in the documentation of a class, which tells 
+# the reader which header file to include in order to use a class. 
+# If left blank only the name of the header file containing the class 
+# definition is used. Otherwise one should specify the include paths that 
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful is your file systems 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like regular Qt-style comments 
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will 
+# interpret the first line (until the first dot) of a Qt-style 
+# comment as the brief description. If set to NO, the comments 
+# will behave just like regular Qt-style comments (thus requiring 
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce 
+# a new page for each member. If set to NO, the documentation of a member will 
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C 
+# sources only. Doxygen will then generate output that is more tailored for C. 
+# For instance, some of the names that are used will be different. The list 
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java 
+# sources only. Doxygen will then generate output that is more tailored for 
+# Java. For instance, namespaces will be presented as packages, qualified 
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran 
+# sources only. Doxygen will then generate output that is more tailored for 
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL 
+# sources. Doxygen will then generate output that is tailored for 
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it 
+# parses. With this tag you can assign which parser to use for a given extension. 
+# Doxygen has a built-in mapping, but you can override or extend it using this 
+# tag. The format is ext=language, where ext is a file extension, and language 
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C, 
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make 
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C 
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions 
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+
+EXTENSION_MAPPING      = 
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want 
+# to include (a tag file for) the STL sources as input, then you should 
+# set this tag to YES in order to let doxygen match functions declarations and 
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. 
+# func(std::string) {}). This also make the inheritance and collaboration 
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to 
+# enable parsing support.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. 
+# Doxygen will parse them like normal C++ but will assume all classes use public 
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter 
+# and setter methods for a property. Setting this option to YES (the default) 
+# will make doxygen to replace the get and set methods by a property in the 
+# documentation. This will only work if the methods are indeed getting or 
+# setting a simple type. If this is not the case, or you want to show the 
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum 
+# is documented as struct, union, or enum with the name of the typedef. So 
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct 
+# with name TypeT. When disabled the typedef will appear as a member of a file, 
+# namespace, or class. And the struct will be named TypeS. This can typically 
+# be useful for C code in case the coding convention dictates that all compound 
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to 
+# determine which symbols to keep in memory and which to flush to disk. 
+# When the cache is full, less often used symbols will be written to disk. 
+# For small to medium size projects (<1000 input files) the default value is 
+# probably good enough. For larger projects a too small cache size can cause 
+# doxygen to be busy swapping symbols to and from disk most of the time 
+# causing a significant performance penality. 
+# If the system has enough physical memory increasing the cache will improve the 
+# performance by keeping more symbols in memory. Note that the value works on 
+# a logarithmic scale so increasing the size by one will rougly double the 
+# memory usage. The cache size is given by this formula: 
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, 
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local 
+# methods, which are defined in the implementation section but not in 
+# the interface are included in the documentation. 
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be 
+# extracted and appear in the documentation as a namespace called 
+# 'anonymous_namespace{file}', where file will be replaced with the base 
+# name of the file that contains the anonymous namespace. By default 
+# anonymous namespace are hidden.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen 
+# will list include files with double quotes in the documentation 
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
+# brief documentation of file, namespace and class members alphabetically 
+# by member name. If set to NO (the default) the members will appear in 
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen 
+# will sort the (brief and detailed) documentation of class members so that 
+# constructors and destructors are listed first. If set to NO (the default) 
+# the constructors will appear in the respective orders defined by 
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. 
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO 
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the 
+# hierarchy of group names into alphabetical order. If set to NO (the default) 
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
+# sorted by fully-qualified names, including namespaces. If set to 
+# NO (the default), the class list will be sorted only by class name, 
+# not including the namespace part. 
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. 
+# Note: This option applies only to the class list, not to the 
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or define consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and defines in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+# If the sources in your project are distributed over multiple directories 
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy 
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES       = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. 
+# This will remove the Files entry from the Quick Index and from the 
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the 
+# Namespaces page.  This will remove the Namespaces entry from the Quick Index 
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that 
+# doxygen should invoke to get the current version for each file (typically from 
+# the version control system). Doxygen will invoke the program by executing (via 
+# popen()) the command <command> <input-file>, where <command> is the value of 
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file 
+# provided by doxygen. Whatever the program writes to standard output 
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    = 
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed 
+# by doxygen. The layout file controls the global structure of the generated 
+# output files in an output format independent way. The create the layout file 
+# that represents doxygen's defaults, run doxygen with the -l option. 
+# You can optionally specify a file name after the option, if omitted 
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE            = 
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be abled to get warnings for 
+# functions that are documented, but have no documentation for their parameters 
+# or return value. If set to NO (the default) doxygen will only warn about 
+# wrong or incomplete parameter documentation, but not about the absence of 
+# documentation.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. Optionally the format may contain 
+# $version, which will be replaced by the version of the file (if it could 
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces.
+
+INPUT                  = @top_srcdir@
+
+# This tag can be used to specify the character encoding of the source files 
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
+# also the default input encoding. Doxygen uses libiconv (or the iconv built 
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for 
+# the list of possible encodings.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank the following patterns are tested: 
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
+
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.d \
+                         *.java \
+                         *.ii \
+                         *.ixx \
+                         *.ipp \
+                         *.i++ \
+                         *.inl \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.idl \
+                         *.odl \
+                         *.cs \
+                         *.php \
+                         *.php3 \
+                         *.inc \
+                         *.m \
+                         *.mm \
+                         *.dox \
+                         *.py \
+                         *.f90 \
+                         *.f \
+                         *.vhd \
+                         *.vhdl
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = 
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
+# directories that are symbolic links (a Unix filesystem feature) are excluded 
+# from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. Note that the wildcards are matched 
+# against the file with absolute path, so to exclude all test directories 
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = 
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names 
+# (namespaces, classes, functions, etc.) that should be excluded from the 
+# output. The symbol name can be a fully qualified name, a word, or if the 
+# wildcard * is used, a substring. Examples: ANamespace, AClass, 
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS        = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
+# basis.  Doxygen will compare the file name with each pattern and apply the 
+# filter if there is a match.  The filters are a list of the form: 
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER 
+# is applied to all files.
+
+FILTER_PATTERNS        = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) 
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from 
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will 
+# link to the source code.  Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code 
+# will point to the HTML generated by the htags(1) tool instead of doxygen 
+# built-in source browser. The htags tool is part of GNU's global source 
+# tagging system (see http://www.gnu.org/software/global/global.html). You 
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = 
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. 
+# Doxygen will adjust the colors in the stylesheet and background images 
+# according to this color. Hue is specified as an angle on a colorwheel, 
+# see http://en.wikipedia.org/wiki/Hue for more information. 
+# For instance the value 0 represents red, 60 is yellow, 120 is green, 
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again. 
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of 
+# the colors in the HTML output. For a value of 0 the output will use 
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to 
+# the luminance component of the colors in the HTML output. Values below 
+# 100 gradually make the output lighter, whereas values above 100 make 
+# the output darker. The value divided by 100 is the actual gamma applied, 
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2, 
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML 
+# page will contain the date and time when the page was generated. Setting 
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML 
+# documentation will contain sections that can be hidden and shown after the 
+# page has loaded. For this to work a browser that supports 
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox 
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files 
+# will be generated that can be used as input for Apple's Xcode 3 
+# integrated development environment, introduced with OSX 10.5 (Leopard). 
+# To create a documentation set, doxygen will generate a Makefile in the 
+# HTML output directory. Running make will produce the docset in that 
+# directory and running "make install" will install the docset in 
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find 
+# it at startup. 
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html 
+# for more information.
+
+GENERATE_DOCSET        = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the 
+# feed. A documentation feed provides an umbrella under which multiple 
+# documentation sets from a single provider (such as a company or product suite) 
+# can be grouped.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that 
+# should uniquely identify the documentation set bundle. This should be a 
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen 
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify 
+# the documentation publisher. This should be a reverse domain-name style 
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING 
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file 
+# content.
+
+CHM_INDEX_ENCODING     = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and 
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated 
+# that can be used as input for Qt's qhelpgenerator to generate a 
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can 
+# be used to specify the file name of the resulting .qch file. 
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE               = 
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating 
+# Qt Help Project output. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating 
+# Qt Help Project output. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to 
+# add. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME   = 
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the 
+# custom filter to add. For more information please see 
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters"> 
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS  = 
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this 
+# project's 
+# filter section matches. 
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes"> 
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS  = 
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can 
+# be used to specify the location of Qt's qhelpgenerator. 
+# If non-empty doxygen will try to run qhelpgenerator on the generated 
+# .qhp file.
+
+QHG_LOCATION           = 
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files  
+# will be generated, which together with the HTML files, form an Eclipse help 
+# plugin. To install this plugin and make it available under the help contents 
+# menu in Eclipse, the contents of the directory containing the HTML and XML 
+# files needs to be copied into the plugins directory of eclipse. The name of 
+# the directory within the plugins directory should be the same as 
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before 
+# the help appears.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin 
+# the directory name containing the HTML and XML files should also have 
+# this name.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [1..20]) 
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index 
+# structure should be generated to display hierarchical information. 
+# If the tag value is set to YES, a side panel will be generated 
+# containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser). 
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = NO
+
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories, 
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+
+USE_INLINE_TREES       = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open 
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of Latex formulas included 
+# as images in the HTML documentation. The default is 10. Note that 
+# when you change the font size after a successful doxygen run you need 
+# to manually remove any form_*.png images from the HTML output directory 
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images 
+# generated for formulas are transparent PNGs. Transparent PNGs are 
+# not supported properly for IE 6.0, but are supported on all modern browsers. 
+# Note that when changing this option you need to delete any form_*.png files 
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT    = YES
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box 
+# for the HTML output. The underlying search engine uses javascript 
+# and DHTML and should work on any modern browser. Note that when using 
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets 
+# (GENERATE_DOCSET) there is already a search function so this one should 
+# typically be disabled. For large projects the javascript based search engine 
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE           = NO
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be 
+# implemented using a PHP enabled web server instead of at the web client 
+# using Javascript. Doxygen will generate the search PHP script and index 
+# file to put on the web server. The advantage of the server 
+# based approach is that it scales better to large projects and allows 
+# full text search. The disadvances is that it is more difficult to setup 
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name. 
+# Note that when enabling USE_PDFLATEX this option is only used for 
+# generating bitmaps for formulas in the HTML output, but not in the 
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include 
+# source code with syntax highlighting in the LaTeX output. 
+# Note that which sources are shown also depends on other settings 
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE      = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
+# dump the program listings (including syntax highlighting 
+# and cross-referencing information) to the XML output. Note that 
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader.  This is useful 
+# if you want to understand what is going on.  On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. To prevent a macro definition from being 
+# undefined via #undef or recursively expanded use the := operator 
+# instead of the = operator.
+
+PREDEFINED             = 
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED      = 
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
+# doxygen's preprocessor will remove all function-like macros that are alone 
+# on a line, have an all uppercase name, and do not end with a semicolon. Such 
+# function macros are typically used for boiler-plate code, and will confuse 
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#   TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#   TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links. 
+# Note that each tag file must have a unique name 
+# (where the name does NOT include the path) 
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
+# or super classes. Setting the tag to NO turns the diagrams off. Note that 
+# this option is superseded by the HAVE_DOT option below. This is only a 
+# fallback. It is recommended to install and use dot, since it yields more 
+# powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc 
+# command. Doxygen will then run the mscgen tool (see 
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the 
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where 
+# the mscgen tool resides. If left empty the tool is assumed to be found in the 
+# default search path.
+
+MSCGEN_PATH            = 
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is 
+# allowed to run in parallel. When set to 0 (the default) doxygen will 
+# base this on the number of processors available in the system. You can set it 
+# explicitly to a value larger than 0 to get control over the balance 
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS        = 0
+
+# By default doxygen will write a font called FreeSans.ttf to the output 
+# directory and reference it in all dot files that doxygen generates. This 
+# font does not include all possible unicode characters however, so when you need 
+# these (or just want a differently looking font) you can specify the font name 
+# using DOT_FONTNAME. You need need to make sure dot is able to find the font, 
+# which can be done by putting it in a standard location or by setting the 
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory 
+# containing the font.
+
+DOT_FONTNAME           = FreeSans.ttf
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. 
+# The default size is 10pt.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the output directory to look for the 
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a 
+# different font using DOT_FONTNAME you can set the path where dot 
+# can find it using this tag.
+
+DOT_FONTPATH           = 
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then 
+# doxygen will generate a call dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable call graphs 
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then 
+# doxygen will generate a caller dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable caller 
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES 
+# then doxygen will show the dependencies a directory has on other directories 
+# in a graphical way. The dependency relations are determined by the #include 
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, jpg, or gif 
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               = 
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of 
+# nodes that will be shown in the graph. If the number of nodes in a graph 
+# becomes larger than this value, doxygen will truncate the graph, which is 
+# visualized by representing a node as a red box. Note that doxygen if the 
+# number of direct children of the root node in a graph is already larger than 
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note 
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the 
+# graphs generated by dot. A depth value of 3 means that only nodes reachable 
+# from the root by following a path via at most 3 edges will be shown. Nodes 
+# that lay further from the root node will be omitted. Note that setting this 
+# option to 1 or 2 may greatly reduce the computation time needed for large 
+# code bases. Also note that the size of a graph can be further restricted by 
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent 
+# background. This is disabled by default, because dot on Windows does not 
+# seem to support this out of the box. Warning: Depending on the platform used, 
+# enabling this option may lead to badly anti-aliased labels on the edges of 
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output 
+# files in one run (i.e. multiple -o and -T options on the command line). This 
+# makes dot run faster, but since only newer versions of dot (>1.8.10) 
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
index 0d82600..a5cf59c 100644 (file)
 
 using namespace zipper;
 
-ZipException::ZipException(const std::string& what) :
+Exception::Exception(const std::string& what) :
        std::runtime_error(what)
 {
 }
 
-ZipFormatException::ZipFormatException(const std::string& what) :
-       ZipException(what)
+FormatException::FormatException(const std::string& what) :
+       Exception(what)
 {
 }
 
-ZipUnsupportedException::ZipUnsupportedException(const std::string& what) :
-       ZipException(what)
+UnsupportedException::UnsupportedException(const std::string& what) :
+       Exception(what)
+{
+}
+
+IOException::IOException(const std::string& what) :
+       Exception(what)
 {
 }
 
diff --git a/FileReader.cc b/FileReader.cc
new file mode 100644 (file)
index 0000000..8fc5a3b
--- /dev/null
@@ -0,0 +1,181 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+
+#include <cassert>
+#include <sstream>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+using namespace zipper;
+
+class FileReader::FileReaderImpl
+{
+public:
+       FileReaderImpl(const std::string& filename) :
+               m_filename(filename),
+               m_fd(-1),
+               m_closeOnExit(true)
+       {
+               m_fd = ::open(filename.c_str(), O_RDONLY);
+
+               if (m_fd < 0)
+               {
+                       char buf[1024];
+                       strerror_r(errno, buf, sizeof(buf));
+
+                       std::stringstream message;
+                       message << "Could not open file \"" << filename << "\": " <<
+                               buf;
+                       throw IOException(message.str());
+               }
+               initSize();
+       }
+
+       FileReaderImpl(const std::string& filename, int fd, bool closeFd) :
+               m_filename(filename),
+               m_fd(fd),
+               m_closeOnExit(closeFd)
+       {
+               initSize();
+       }
+
+       ~FileReaderImpl()
+       {
+               close();
+       }
+
+       const std::string& getSourceName() const { return m_filename; }
+
+       zsize_t getSize() const { return m_size; }
+
+       virtual void readData(
+               zsize_t offset, zsize_t bytes, uint8_t* dest
+               ) const
+       {
+               assert(m_fd >= 0);
+
+               zsize_t bytesRead(0);
+               while(bytesRead < bytes)
+               {
+                       ssize_t currentBytes(
+                               pread(
+                                       m_fd,
+                                       dest + bytesRead,
+                                       bytes - bytesRead,
+                                       offset + bytesRead)
+                               );
+
+                       if (currentBytes > 0)
+                       {
+                               bytesRead += static_cast<zsize_t>(currentBytes);
+                       }
+                       else if (currentBytes == 0)
+                       {
+                               throw FormatException("Unexpected end-of-file");
+                       }
+                       else if ((currentBytes < 0) && (errno != EINTR))
+                       {
+                               char buf[1024];
+                               strerror_r(errno, buf, sizeof(buf));
+                               throw IOException(buf);
+                       }
+               }
+       }
+
+private:
+       void initSize()
+       {
+               // If we fail here, we need to essentially run the dtor manually.
+               // initSize is called from the constructors, and so the dtor will
+               // NOT run if an exception is thrown.
+
+               struct stat buf;
+               int result(fstat(m_fd, &buf));
+               if (result != 0)
+               {
+                       int errnoLocal = errno;
+                       close();
+
+                       char buf[1024];
+                       strerror_r(errnoLocal, buf, sizeof(buf));
+
+                       std::stringstream message;
+                       message << "Could not get filesize for file " <<
+                               "\"" << m_filename << "\": " << buf;
+                       throw IOException(message.str());
+               }
+               else
+               {
+                       m_size = buf.st_size;
+               }
+       }
+
+       void close()
+       {
+               if ((m_fd >= 0) && m_closeOnExit)
+               {
+                       ::close(m_fd);
+                       m_fd = -1;
+               }
+       }
+       std::string m_filename;
+       int m_fd;
+       bool m_closeOnExit;
+       zsize_t m_size;
+};
+
+FileReader::FileReader(const std::string& filename) :
+       m_impl(new FileReaderImpl(filename))
+{
+}
+
+FileReader::FileReader(const std::string& filename, int fd, bool closeFd) :
+       m_impl(new FileReaderImpl(filename, fd, closeFd))
+{
+}
+
+FileReader::~FileReader()
+{
+       delete m_impl;
+}
+
+const std::string&
+FileReader::getSourceName() const
+{
+       return m_impl->getSourceName();
+}
+
+zsize_t
+FileReader::getSize() const
+{
+       return m_impl->getSize();
+}
+
+void
+FileReader::readData(
+       zsize_t offset, zsize_t bytes, uint8_t* dest
+       ) const
+{
+       return m_impl->readData(offset, bytes, dest);
+}
+
diff --git a/FileWriter.cc b/FileWriter.cc
new file mode 100644 (file)
index 0000000..b595a50
--- /dev/null
@@ -0,0 +1,148 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+
+#include <algorithm>
+#include <cassert>
+#include <sstream>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+using namespace zipper;
+
+class FileWriter::FileWriterImpl
+{
+public:
+       FileWriterImpl(const std::string& filename, mode_t createPermissions) :
+               m_filename(filename),
+               m_fd(-1),
+               m_closeOnExit(true)
+       {
+               m_fd =
+                       ::open(
+                               filename.c_str(),
+                               O_WRONLY | O_TRUNC | O_CREAT,
+                               createPermissions);
+
+               if (m_fd < 0)
+               {
+                       char buf[1024];
+                       strerror_r(errno, buf, sizeof(buf));
+
+                       std::stringstream message;
+                       message << "Could not open file \"" << filename << "\": " <<
+                               buf;
+                       throw IOException(message.str());
+               }
+       }
+
+       FileWriterImpl(const std::string& filename, int fd, bool closeFd) :
+               m_filename(filename),
+               m_fd(fd),
+               m_closeOnExit(closeFd)
+       {
+       }
+
+       ~FileWriterImpl()
+       {
+               close();
+       }
+
+       virtual void writeData(
+               zsize_t offset, zsize_t bytes, const uint8_t* data
+               ) const
+       {
+               assert(m_fd >= 0);
+
+               zsize_t bytesWritten(0);
+               while(bytesWritten < bytes)
+               {
+                       ssize_t currentBytes(
+                               pwrite(
+                                       m_fd,
+                                       data + bytesWritten,
+                                       bytes - bytesWritten,
+                                       offset + bytesWritten)
+                               );
+
+                       if (currentBytes >= 0)
+                       {
+                               bytesWritten += static_cast<zsize_t>(currentBytes);
+                       }
+                       else if ((currentBytes < 0) && (errno != EINTR))
+                       {
+                               char buf[1024];
+                               strerror_r(errno, buf, sizeof(buf));
+                               throw IOException(buf);
+                       }
+               }
+       }
+
+       zsize_t getSize() const
+       {
+               assert(m_fd >= 0);
+               zsize_t result(lseek(m_fd, 0, SEEK_END));
+               return result;
+       }
+
+private:
+       void close()
+       {
+               if ((m_fd >= 0) && m_closeOnExit)
+               {
+                       ::close(m_fd);
+                       m_fd = -1;
+               }
+       }
+
+       std::string m_filename;
+       int m_fd;
+       bool m_closeOnExit;
+};
+
+FileWriter::FileWriter(const std::string& filename, mode_t createPermissions) :
+       m_impl(new FileWriterImpl(filename, createPermissions))
+{
+}
+
+FileWriter::FileWriter(const std::string& filename, int fd, bool closeFd) :
+       m_impl(new FileWriterImpl(filename, fd, closeFd))
+{
+}
+
+FileWriter::~FileWriter()
+{
+       delete m_impl;
+}
+
+void
+FileWriter::writeData(zsize_t offset, zsize_t bytes, const uint8_t* data)
+{
+       m_impl->writeData(offset, bytes, data);
+}
+
+zsize_t
+FileWriter::getSize() const
+{
+       return m_impl->getSize();
+}
+
index aa6d4ec..287d6f0 100644 (file)
@@ -15,6 +15,8 @@
 #      You should have received a copy of the GNU General Public License
 #      along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
 
+include doxygen.am
+
 dist_noinst_SCRIPTS = autogen.sh
 
 EXTRA_DIST = \
@@ -27,11 +29,22 @@ EXTRA_DIST = \
 
 lib_LTLIBRARIES = libzipper.la
 libzipper_la_SOURCES = \
+       Compressor.cc \
        CompressedFile.cc \
-       Consumer.cc \
+       Container.cc \
+       Decompressor.cc \
        Exception.cc \
-       Provider.cc \
+       FileReader.cc \
+       FileWriter.cc \
+       Reader.cc \
+       Ungzip.cc \
+       Ungzip.hh \
        Unzip.cc \
+       Unzip.hh \
+       util.hh \
+       Writer.cc \
+       Zip.hh \
+       Zip.cc \
        zipper.hh
 
 libzipper_la_LDFLAGS = ${ZLIB_LIBS}
@@ -46,3 +59,5 @@ zipper_LDADD = libzipper.la
 
 CXXFLAGS=-g -O2 -W -Wall -Werror -std=c++0x
 
+MOSTLYCLEANFILES=$(DX_CLEANFILES)
+
diff --git a/Provider.cc b/Provider.cc
deleted file mode 100644 (file)
index 474ad71..0000000
+++ /dev/null
@@ -1,25 +0,0 @@
-//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
-//
-//     This file is part of libzipper.
-//
-//     libzipper is free software: you can redistribute it and/or modify
-//     it under the terms of the GNU General Public License as published by
-//     the Free Software Foundation, either version 3 of the License, or
-//     (at your option) any later version.
-//
-//     libzipper is distributed in the hope that it will be useful,
-//     but WITHOUT ANY WARRANTY; without even the implied warranty of
-//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//     GNU General Public License for more details.
-//
-//     You should have received a copy of the GNU General Public License
-//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "zipper.hh"
-
-using namespace zipper;
-
-Provider::~Provider()
-{
-}
-
diff --git a/README b/README
index bbdb593..9810ba6 100644 (file)
--- a/README
+++ b/README
@@ -1,7 +1,7 @@
 libzipper
 Michael McMaster <michael@codesrc.com>
 
-Flexible C++ interface for reading compressed files in
+libzipper offers a flexible C++ interface for reading compressed files in
 multiple formats.
 
 Supported Formats
diff --git a/Reader.cc b/Reader.cc
new file mode 100644 (file)
index 0000000..fe0b377
--- /dev/null
+++ b/Reader.cc
@@ -0,0 +1,25 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+
+using namespace zipper;
+
+Reader::~Reader()
+{
+}
+
diff --git a/Ungzip.cc b/Ungzip.cc
new file mode 100644 (file)
index 0000000..774d6c6
--- /dev/null
+++ b/Ungzip.cc
@@ -0,0 +1,309 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+#include "Ungzip.hh"
+
+#include <zlib.h>
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <vector>
+
+#include <string.h>
+
+using namespace zipper;
+
+namespace
+{
+       uint32_t
+       read32(const uint8_t* zipData)
+       {
+               // Read 4 bytes in little-endian order.
+               // Return results in host-endian.
+               return uint32_t(
+                       zipData[0] |
+                       (uint32_t(zipData[1]) << 8) |
+                       (uint32_t(zipData[2]) << 16) |
+                       (uint32_t(zipData[3]) << 24)
+                       );
+       }
+
+       uint16_t
+       read16(const std::vector<uint8_t>& zipData, size_t pos)
+       {
+               // Read 2 bytes in little-endian order.
+               // Return results in host-endian.
+               return uint16_t(
+                       zipData[pos] |
+                       (uint16_t(zipData[pos+1]) << 8)
+                       );
+       }
+
+
+       size_t
+       findNull(const std::vector<uint8_t>& zipData, size_t start)
+       {
+               if (start >= zipData.size())
+               {
+                       throw FormatException("Unexpected end-of-file");
+               }
+
+               while (zipData[start] != 0)
+               {
+                       ++start;
+                       if (start >= zipData.size())
+                       {
+                               throw FormatException("Unexpected end-of-file");
+                       }
+               }
+               return start;
+       }
+
+       struct InflateDeleter
+       {
+       public:
+               InflateDeleter(z_stream* stream) : m_stream(stream) {}
+               ~InflateDeleter()
+               {
+                       inflateEnd(m_stream);
+
+               }
+       private:
+               z_stream* m_stream;
+       };
+
+       class FileEntry : public CompressedFile
+       {
+       public:
+               FileEntry(
+                       const ReaderPtr& reader,
+                       zsize_t dataOffset,
+                       const std::string& filename
+                       ) :
+                       m_reader(reader),
+                       m_dataOffset(dataOffset),
+                       m_fileName(filename)
+               {
+               }
+
+               virtual bool isDecompressSupported() const
+               {
+                       return true;
+               }
+
+               virtual const std::string& getPath() const
+               {
+                       return m_fileName;
+               }
+
+               virtual zsize_t getCompressedSize() const { return -1; }
+               virtual zsize_t getUncompressedSize() const { return -1; }
+
+               virtual void decompress(Writer& writer)
+               {
+                       enum
+                       {
+                               ChunkSize = 64*1024,
+                               WindowBits = 15
+                       };
+
+                       uint8_t inChunk[ChunkSize];
+                       uint8_t outChunk[ChunkSize];
+                       zsize_t endCompressedBytes = m_reader->getSize() - 8; // CRC+ISIZE
+                       uint32_t crc(crc32(0, NULL, 0));
+
+                       z_stream stream;
+                       stream.zalloc = NULL;
+                       stream.zfree = NULL;
+                       stream.opaque = NULL;
+                       int zlibErr(inflateInit2(&stream, -WindowBits));
+                       assert(zlibErr == Z_OK);
+                       InflateDeleter deleter(&stream);
+                       stream.next_in = NULL;
+                       stream.avail_in = 0;
+
+                       bool finished(false);
+                       zsize_t pos(m_dataOffset);
+                       zsize_t outPos(0);
+                       while (pos < endCompressedBytes)
+                       {
+                               if (stream.avail_in == 0)
+                               {
+                                       stream.avail_in =
+                                               std::min(
+                                                       zsize_t(ChunkSize),
+                                                       endCompressedBytes - pos
+                                                       );
+                                       m_reader->readData(
+                                               pos, stream.avail_in, &inChunk[0]
+                                               );
+                                       stream.next_in = reinterpret_cast<Bytef*>(&inChunk);
+                                       pos += stream.avail_in;
+                               }
+
+                               stream.next_out = reinterpret_cast<Bytef*>(&outChunk);
+                               stream.avail_out = sizeof(outChunk);
+
+                               zlibErr = inflate(&stream, Z_SYNC_FLUSH);
+
+                               finished = false;
+                               if (zlibErr == Z_STREAM_END)
+                               {
+                                       finished = true;
+                               }
+                               else if (zlibErr != Z_OK)
+                               {
+                                       throw FormatException("Corrupt Data");
+                               }
+
+                               zsize_t bytesToWrite(sizeof(outChunk) - stream.avail_out);
+                               writer.writeData(outPos, bytesToWrite, &outChunk[0]);
+                               outPos += bytesToWrite;
+                               crc = crc32(crc, &outChunk[0], bytesToWrite);
+
+                               if (finished) break;
+                       }
+
+                       if (!finished)
+                       {
+                               // Ran out of data to process
+                               throw FormatException("Corrupt Data");
+                       }
+
+                       uint8_t crcBuffer[4];
+                       ::memcpy(crcBuffer, stream.next_in, std::min(4u, stream.avail_in));
+
+                       if (stream.avail_in < 4)
+                       {
+                               m_reader->readData(
+                                       pos, 4 - stream.avail_in, &crcBuffer[stream.avail_in]
+                                       );
+                       }
+                       uint32_t savedCRC = read32(&crcBuffer[0]);
+                       if (savedCRC != crc)
+                       {
+                               throw FormatException("Corrupt Data (CRC Failure)");
+                       }
+               }
+
+       private:
+               ReaderPtr m_reader;
+               zsize_t m_dataOffset;
+               std::string m_fileName;
+       };
+}
+
+namespace zipper
+{
+       std::vector<CompressedFilePtr>
+       ungzip(const ReaderPtr& reader)
+       {
+               enum
+               {
+                       MaxHeader = 64*1024  // Artifical limit to simplify code
+               };
+
+               if (!isGzip(reader))
+               {
+                       throw FormatException("Invalid gzip file");
+               }
+
+               std::vector<uint8_t> header(
+                       std::min(reader->getSize(), zsize_t(MaxHeader)));
+               reader->readData(0, header.size(), &header[0]);
+
+               if (header[2] != 8) // "deflate" method
+               {
+                       throw UnsupportedException("Unknown gzip compression method");
+               }
+
+               bool fextra = (header[3] & 4) != 0;
+               bool fname = (header[3] & 8) != 0;
+               bool fcomment = (header[3] & 0x10) != 0;
+               bool fhcrc = (header[3] & 2) != 0;
+
+               size_t offset(10);
+
+               if (fextra)
+               {
+                       if (offset + 2 > header.size())
+                       {
+                               throw FormatException("Unexpected end-of-file");
+                       }
+                       uint16_t fextraBytes(read16(header, offset));
+                       offset += 2;
+
+                       offset += fextraBytes;
+               }
+
+               std::string embeddedName(reader->getSourceName());
+               if (fname)
+               {
+                       size_t nullOffset(findNull(header, offset));
+                       embeddedName =
+                               std::string(
+                                       reinterpret_cast<char*>(&header[offset]),
+                                       nullOffset - offset);
+                       offset = nullOffset + 1;
+               }
+
+               if (fcomment)
+               {
+                       size_t nullOffset(findNull(header, offset));
+                       offset = nullOffset + 1;
+               }
+
+               if (fhcrc)
+               {
+                       offset += 2;
+               }
+
+               if (offset >= header.size())
+               {
+                       throw FormatException("Unexpected end-of-file");
+               }
+
+               std::vector<CompressedFilePtr> result;
+               result.push_back(
+                       CompressedFilePtr(new FileEntry(reader, offset, embeddedName)));
+
+               return result;
+       }
+
+       bool
+       isGzip(const ReaderPtr& reader)
+       {
+               enum Constants
+               {
+                       MinFileBytes = 18, // Header + CRC + size
+                       ID1 = 0x1f,
+                       ID2 = 0x8b
+               };
+
+               bool isGzip(false);
+               if (reader->getSize() >= MinFileBytes)
+               {
+                       uint8_t magic[2];
+                       reader->readData(0, sizeof(magic), &magic[0]);
+                       isGzip = (magic[0] == ID1) && (magic[1] == ID2);
+               }
+               return isGzip;
+       }
+}
+
diff --git a/Ungzip.hh b/Ungzip.hh
new file mode 100644 (file)
index 0000000..95d445b
--- /dev/null
+++ b/Ungzip.hh
@@ -0,0 +1,28 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+
+#include <vector>
+
+namespace zipper
+{
+       bool isGzip(const ReaderPtr& reader);
+
+       std::vector<CompressedFilePtr> ungzip(const ReaderPtr& reader);
+}
+
index 6e2253c..7845d91 100644 (file)
--- a/Unzip.cc
+++ b/Unzip.cc
@@ -16,6 +16,7 @@
 //     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "zipper.hh"
+#include "Unzip.hh"
 
 #include <zlib.h>
 
 #include <cassert>
 #include <iostream>
 
+#include <string.h>
+
 using namespace zipper;
 
 namespace
 {
+       template<typename T>
        uint32_t
-       read32(const std::vector<uint8_t>& zipData, size_t pos)
+       read32(const T& zipData, size_t pos)
        {
                // Read 4 bytes in little-endian order.
                // Return results in host-endian.
@@ -68,44 +72,47 @@ namespace
        {
        public:
                FileEntry(
-                       ProviderPtr provider,
+                       const ReaderPtr& reader,
                        uint16_t versionNeeded,
                        uint16_t gpFlag,
                        uint16_t compressionMethod,
-                       uint16_t lastModTime,
-                       uint16_t lastModDate,
-                       uint32_t crc32,
-                       uint32_t compressedSize,
-                       uint32_t uncompressedSize,
-                       uint32_t localHeaderOffset,
-                       std::string fileName,
-                       std::string extra,
-                       std::string comment
+                       uint32_t crc,
+                       zsize_t compressedSize,
+                       zsize_t uncompressedSize,
+                       zsize_t localHeaderOffset,
+                       std::string fileName
                        ) :
-                       m_provider(provider),
+                       m_reader(reader),
                        m_versionNeeded(versionNeeded),
                        m_gpFlag(gpFlag),
                        m_compressionMethod(compressionMethod),
-                       m_lastModTime(lastModTime),
-                       m_lastModDate(lastModDate),
-                       m_crc32(crc32),
+                       m_crc(crc),
                        m_compressedSize(compressedSize),
                        m_uncompressedSize(uncompressedSize),
                        m_localHeaderOffset(localHeaderOffset),
-                       m_fileName(fileName),
-                       m_extra(extra),
-                       m_comment(comment)
+                       m_fileName(fileName)
                {
                }
 
-               virtual bool isValid() const
+               virtual bool isDecompressSupported() const
                {
                        return ((m_versionNeeded & 0xf) <= 20) &&
                                ((m_gpFlag & 0x1) == 0) && // Not encrypted
-                               (m_compressionMethod <= 8);
+                               ((m_compressionMethod == 0) || (m_compressionMethod == 8));
                }
 
-               virtual void uncompress(Consumer& consumer)
+               virtual const std::string& getPath() const
+               {
+                       return m_fileName;
+               }
+
+               virtual zsize_t getCompressedSize() const { return m_compressedSize; }
+               virtual zsize_t getUncompressedSize() const
+               {
+                       return m_uncompressedSize;
+               }
+
+               virtual void decompress(Writer& writer)
                {
                        enum
                        {
@@ -116,51 +123,51 @@ namespace
                        };
 
                        std::vector<uint8_t> localRecord(MinRecordBytes);
-                       m_provider->zip_readData(
+                       m_reader->readData(
                                m_localHeaderOffset, MinRecordBytes, &localRecord[0]
                                );
                        if (read32(localRecord, 0) != Signature)
                        {
-                               throw ZipFormatException("Invalid local ZIP record");
+                               throw FormatException("Invalid local ZIP record");
                        }
 
                        // Don't trust the lengths for filename and extra content read from
                        // the central records.  At least for extra, these DO differ for
                        // unknown reasons
-                       size_t filenameLength(read16(localRecord, 26));
-                       size_t extraLength(read16(localRecord, 28));
+                       zsize_t filenameLength(read16(localRecord, 26));
+                       zsize_t extraLength(read16(localRecord, 28));
 
-                       zoff64_t startCompressedBytes(
+                       zsize_t startCompressedBytes(
                                m_localHeaderOffset +
                                MinRecordBytes +
                                filenameLength +
                                extraLength
                                );
 
-                       zoff64_t endCompressedBytes(
+                       zsize_t endCompressedBytes(
                                startCompressedBytes + m_compressedSize
                                );
 
-                       if (endCompressedBytes > m_provider->zip_getSize())
+                       if (endCompressedBytes > m_reader->getSize())
                        {
-                               throw ZipFormatException("Compressed file size is too long");
+                               throw FormatException("Compressed file size is too long");
                        }
 
                        switch (m_compressionMethod)
                        {
                        case 0: // No compression
                        {
-                               for (zoff64_t pos(startCompressedBytes);
+                               for (zsize_t pos(startCompressedBytes);
                                        pos < endCompressedBytes;
                                        pos += ChunkSize
                                        )
                                {
                                        uint8_t buf[ChunkSize];
-                                       size_t bytes(
-                                               std::min(zoff64_t(ChunkSize), endCompressedBytes - pos)
+                                       zsize_t bytes(
+                                               std::min(zsize_t(ChunkSize), endCompressedBytes - pos)
                                                );
-                                       m_provider->zip_readData(pos, bytes, &buf[0]);
-                                       consumer.zip_writeData(bytes, &buf[0]);
+                                       m_reader->readData(pos, bytes, &buf[0]);
+                                       writer.writeData(pos, bytes, &buf[0]);
                                }
                        }; break;
 
@@ -178,23 +185,25 @@ namespace
                                InflateDeleter deleter(&stream);
                                stream.next_in = NULL;
                                stream.avail_in = 0;
+                               bool finished(false);
 
-                               for (zoff64_t pos(startCompressedBytes);
-                                       pos < endCompressedBytes;
-                                       pos += ChunkSize
-                                       )
+                               zsize_t pos(startCompressedBytes);
+                               zsize_t outPos(0);
+                               uint32_t crc(crc32(0, NULL, 0));
+                               while (pos < endCompressedBytes)
                                {
                                        if (stream.avail_in == 0)
                                        {
                                                stream.avail_in =
                                                        std::min(
-                                                               zoff64_t(ChunkSize),
+                                                               zsize_t(ChunkSize),
                                                                endCompressedBytes - pos
                                                                );
-                                               m_provider->zip_readData(
+                                               m_reader->readData(
                                                        pos, stream.avail_in, &inChunk[0]
                                                        );
                                                stream.next_in = reinterpret_cast<Bytef*>(&inChunk);
+                                               pos += stream.avail_in;
                                        }
 
                                        stream.next_out = reinterpret_cast<Bytef*>(&outChunk);
@@ -202,95 +211,167 @@ namespace
 
                                        zlibErr = inflate(&stream, Z_SYNC_FLUSH);
 
-                                       bool finished(false);
+                                       finished = false;
                                        if (zlibErr == Z_STREAM_END)
                                        {
                                                finished = true;
+
                                        }
                                        else if (zlibErr != Z_OK)
                                        {
-                                               throw ZipFormatException("Corrupt Data");
+                                               throw FormatException("Corrupt Data");
                                        }
 
-                                       consumer.zip_writeData(
-                                               sizeof(outChunk) - stream.avail_out,
+                                       zsize_t bytesToWrite(sizeof(outChunk) - stream.avail_out);
+                                       writer.writeData(
+                                               outPos,
+                                               bytesToWrite,
                                                &outChunk[0]
                                                );
+                                       outPos += bytesToWrite;
+                                       crc = crc32(crc, &outChunk[0], bytesToWrite);
 
                                        if (finished) break;
                                }
-                       }; break;
+                               if (!finished)
+                               {
+                                       // Ran out of data to process
+                                       throw FormatException("Corrupt Data");
+                               }
+
+                               if (m_gpFlag & 0x4) // CRC is after compressed data
+                               {
+                                       uint8_t dataDescriptor[12];
+                                       ::memcpy(
+                                               dataDescriptor,
+                                               stream.next_in,
+                                               std::min(12u, stream.avail_in));
 
+                                       if (stream.avail_in < 12)
+                                       {
+                                               m_reader->readData(
+                                                       pos,
+                                                       12 - stream.avail_in,
+                                                       &dataDescriptor[stream.avail_in]);
+                                       }
+                                       m_crc = read32(dataDescriptor, 0);
+                                       m_compressedSize = read32(dataDescriptor, 4);
+                                       m_uncompressedSize = read32(dataDescriptor, 8);
+                               }
+
+                               if (crc != m_crc)
+                               {
+                                       throw FormatException("Corrupt Data (CRC failure)");
+                               }
+
+                       }; break;
                        default:
-                               throw ZipUnsupportedException("Unsupported compression scheme");
+                               throw UnsupportedException("Unsupported compression scheme");
                        };
                }
 
        private:
-               ProviderPtr m_provider;
+               ReaderPtr m_reader;
                uint16_t m_versionNeeded;
                uint16_t m_gpFlag;
                uint16_t m_compressionMethod;
-               uint16_t m_lastModTime;
-               uint16_t m_lastModDate;
-               uint32_t m_crc32;
-               uint32_t m_compressedSize;
-               uint32_t m_uncompressedSize;
-               uint32_t m_localHeaderOffset;
+               uint32_t m_crc;
+               zsize_t m_compressedSize;
+               zsize_t m_uncompressedSize;
+               zsize_t m_localHeaderOffset;
                std::string m_fileName;
-               std::string m_extra;
-               std::string m_comment;
        };
-}
 
-class Unzip::UnzipImpl
-{
-public:
-       UnzipImpl(const ProviderPtr& provider) :
-               m_provider(provider)
+       bool readEndCentralDirectory(
+               const ReaderPtr& reader,
+               zsize_t& centralDirectoryBytes,
+               zsize_t& centralDirectoryOffset,
+               zsize_t& centralDirectoryEntries
+               )
        {
-               readCentralDirectory();
-       }
+               // Read the end of central directory record. This
+               // record enables us to find the remainding
+               // records without searching for record signatures.
 
-       std::vector<CompressedFilePtr>
-       getEntries() const
-       {
-               return m_entries;
-       }
+               // TODO does not consider the Zip64 entries.
 
-private:
-       ProviderPtr m_provider;
-       std::vector<CompressedFilePtr> m_entries;
+               enum
+               {
+                       MinRecordBytes = 22, // Minimum size with no comment
+                       MaxCommentBytes = 65535, // 2 bytes to store comment length
+                       Signature = 0x06054b50
+               };
 
-       struct EndCentralDirectory
-       {
-               size_t centralDirectoryBytes;
-               size_t centralDirectoryOffset;
-               size_t centralDirectoryEntries;
-               std::string zipFileComment;
-       };
-       EndCentralDirectory m_endCentralDirectory;
+               zsize_t providerSize(reader->getSize());
+               if (providerSize < MinRecordBytes)
+               {
+                       throw FormatException("Too small");
+               }
+
+               size_t bufSize(
+                       std::min(zsize_t(MinRecordBytes + MaxCommentBytes), providerSize)
+                       );
+               std::vector<uint8_t> buffer(bufSize);
+               reader->readData(providerSize - bufSize, bufSize, &buffer[0]);
+
+               // Need to search for this record, as it ends in a variable-length
+               // comment field. Search backwards, with the assumption that the
+               // comment doesn't exist, or is much smaller than the maximum
+               // length
+
+               bool recordFound(false);
+               ssize_t pos(bufSize - MinRecordBytes);
+               for (; pos >= 0; --pos)
+               {
+                       recordFound = (read32(buffer, pos) == Signature);
+                       break;
+               }
+
+               if (recordFound)
+               {
+                       if (read16(buffer, pos + 4) != 0)
+                       {
+                               throw UnsupportedException("Spanned disks not supported");
+                       }
 
-       void readCentralDirectory()
+                       centralDirectoryBytes = read32(buffer, pos + 12);
+                       centralDirectoryOffset = read32(buffer, pos + 16);
+                       centralDirectoryEntries = read16(buffer, pos + 10);
+               }
+               return recordFound;
+       }
+
+       std::vector<CompressedFilePtr>
+       readCentralDirectory(const ReaderPtr& reader)
        {
-               enum
+               enum Constants
                {
                        MinRecordBytes = 46,
                        Signature = 0x02014b50
                };
 
-               readEndCentralDirectory();
-
-               std::vector<uint8_t> buffer(
-                       m_endCentralDirectory.centralDirectoryBytes
+               zsize_t centralDirectoryBytes(0);
+               zsize_t centralDirectoryOffset(0);
+               zsize_t centralDirectoryEntries(0);
+               bool isZip(
+                       readEndCentralDirectory(
+                               reader,
+                               centralDirectoryBytes,
+                               centralDirectoryOffset,
+                               centralDirectoryEntries
+                               )
                        );
-               m_provider->zip_readData(
-                       m_endCentralDirectory.centralDirectoryOffset,
-                       m_endCentralDirectory.centralDirectoryBytes,
+               assert(isZip);
+
+               std::vector<uint8_t> buffer(centralDirectoryBytes);
+               reader->readData(
+                       centralDirectoryOffset,
+                       centralDirectoryBytes,
                        &buffer[0]
                        );
 
-               size_t pos(0);
+               zsize_t pos(0);
+               std::vector<CompressedFilePtr> entries;
                while ((pos + MinRecordBytes) < buffer.size())
                {
                        if (read32(buffer, pos) != Signature)
@@ -303,9 +384,7 @@ private:
                        uint16_t versionNeeded(read16(buffer, pos + 6));
                        uint16_t gpFlag(read16(buffer, pos + 8));
                        uint16_t compressionMethod(read16(buffer, pos + 10));
-                       uint16_t lastModTime(read16(buffer, pos + 12));
-                       uint16_t lastModDate(read16(buffer, pos + 14));
-                       uint32_t crc32(read32(buffer, pos + 16));
+                       uint32_t crc(read32(buffer, pos + 16));
                        uint32_t compressedSize(read32(buffer, pos + 20));
                        uint32_t uncompressedSize(read32(buffer, pos + 24));
                        size_t fileNameLen(read16(buffer, pos + 28));
@@ -317,7 +396,7 @@ private:
                                buffer.size()
                                )
                        {
-                               throw ZipFormatException("File comments are too long");
+                               throw FormatException("File comments are too long");
                        }
 
                        std::string fileName(
@@ -325,124 +404,48 @@ private:
                                &buffer[pos + MinRecordBytes + fileNameLen]
                                );
 
-                       std::string extra(
-                               &buffer[pos+MinRecordBytes+fileNameLen],
-                               &buffer[pos+MinRecordBytes+fileNameLen+extraLen]
-                               );
-
-                       std::string comment(
-                               &buffer[pos+MinRecordBytes+fileNameLen+extraLen],
-                               &buffer[pos+MinRecordBytes+fileNameLen+extraLen+commentLen]
-                               );
-
-                       m_entries.push_back(
+                       entries.push_back(
                                CompressedFilePtr(
                                        new FileEntry(
-                                               m_provider,
+                                               reader,
                                                versionNeeded,
                                                gpFlag,
                                                compressionMethod,
-                                               lastModTime,
-                                               lastModDate,
-                                               crc32,
+                                               crc,
                                                compressedSize,
                                                uncompressedSize,
                                                localHeaderOffset,
-                                               fileName,
-                                               extra,
-                                               comment
+                                               fileName
                                                )
                                        )
                                );
 
                        pos += MinRecordBytes + fileNameLen + extraLen + commentLen;
                }
+               return entries;
        }
-
-       void readEndCentralDirectory()
-       {
-               // Read the end of central directory record. This
-               // record enables us to find the remainding
-               // records without searching for record signatures.
-
-               // TODO does not consider the Zip64 entries.
-
-               enum
-               {
-                       MinRecordBytes = 22, // Minimum size with no comment
-                       MaxCommentBytes = 65535, // 2 bytes to store comment length
-                       Signature = 0x06054b50
-               };
-
-               zoff64_t providerSize(m_provider->zip_getSize());
-               if (providerSize < MinRecordBytes)
-               {
-                       throw ZipFormatException("Too small");
-               }
-
-               size_t bufSize(
-                       std::min(zoff64_t(MinRecordBytes + MaxCommentBytes), providerSize)
-                       );
-               std::vector<uint8_t> buffer(bufSize);
-               m_provider->zip_readData(providerSize - bufSize, bufSize, &buffer[0]);
-
-               // Need to search for this record, as it ends in a variable-length
-               // comment field. Search backwards, with the assumption that the
-               // comment doesn't exist, or is much smaller than the maximum
-               // length
-
-               bool recordFound(false);
-               ssize_t pos(bufSize - MinRecordBytes);
-               for (; pos >= 0; --pos)
-               {
-                       recordFound = (read32(buffer, pos) == Signature);
-                       break;
-               }
-
-               if (!recordFound)
-               {
-                       throw ZipFormatException("ZIP directory records not found");
-               }
-
-               if (read16(buffer, pos + 4) != 0)
-               {
-                       throw ZipUnsupportedException("Spanned disks not supported");
-               }
-
-               m_endCentralDirectory.centralDirectoryBytes = read32(buffer, pos + 12);
-               m_endCentralDirectory.centralDirectoryOffset =
-                       read32(buffer, pos + 16);
-               m_endCentralDirectory.centralDirectoryEntries =
-                       read16(buffer, pos + 10);
-
-               size_t commentLength(read16(buffer, pos + 20));
-               size_t commentStart(pos + MinRecordBytes);
-               if (commentStart + commentLength > bufSize)
-               {
-                       throw ZipFormatException("ZIP comment is too long");
-               }
-               m_endCentralDirectory.zipFileComment =
-                       std::string(
-                               &buffer[commentStart],
-                               &buffer[commentStart + commentLength]
-                               );
-       }
-
-};
-
-Unzip::Unzip(const ProviderPtr& provider) :
-       m_unzipper(new UnzipImpl(provider))
-{
 }
 
-Unzip::~Unzip()
+std::vector<CompressedFilePtr>
+zipper::unzip(const ReaderPtr& reader)
 {
-       delete m_unzipper;
+       return readCentralDirectory(reader);
 }
 
-std::vector<CompressedFilePtr>
-Unzip::getEntries() const
+bool
+zipper::isZip(const ReaderPtr& reader)
 {
-       return m_unzipper->getEntries();
+       zsize_t centralDirectoryBytes(0);
+       zsize_t centralDirectoryOffset(0);
+       zsize_t centralDirectoryEntries(0);
+       bool result(
+               readEndCentralDirectory(
+                       reader,
+                       centralDirectoryBytes,
+                       centralDirectoryOffset,
+                       centralDirectoryEntries
+                       )
+               );
+       return result;
 }
 
diff --git a/Unzip.hh b/Unzip.hh
new file mode 100644 (file)
index 0000000..ab78f9f
--- /dev/null
+++ b/Unzip.hh
@@ -0,0 +1,28 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+
+#include <vector>
+
+namespace zipper
+{
+       bool isZip(const ReaderPtr& reader);
+
+       std::vector<CompressedFilePtr> unzip(const ReaderPtr& reader);
+}
+
diff --git a/Writer.cc b/Writer.cc
new file mode 100644 (file)
index 0000000..8026e39
--- /dev/null
+++ b/Writer.cc
@@ -0,0 +1,25 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+
+using namespace zipper;
+
+Writer::~Writer()
+{
+}
+
diff --git a/Zip.cc b/Zip.cc
new file mode 100644 (file)
index 0000000..8048ece
--- /dev/null
+++ b/Zip.cc
@@ -0,0 +1,296 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+#include "Zip.hh"
+
+#include <zlib.h>
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+
+#include <string.h>
+
+using namespace zipper;
+
+namespace
+{
+       void
+       write32(uint32_t value, uint8_t* zipData)
+       {
+               // Write 4 bytes in little-endian order.
+               zipData[0] = value & 0xff;
+               zipData[1] = (value >> 8) & 0xff;
+               zipData[2] = (value >> 16) & 0xff;
+               zipData[3] = (value >> 24) & 0xff;
+       }
+
+       struct DeflateDeleter
+       {
+       public:
+               DeflateDeleter(z_stream* stream) : m_stream(stream) {}
+               ~DeflateDeleter()
+               {
+                       deflateEnd(m_stream);
+
+               }
+       private:
+               z_stream* m_stream;
+       };
+}
+
+
+void
+zipper::zip(
+       const std::string& filename,
+       const Reader& reader,
+       const WriterPtr& writer,
+       ZipFileRecord& outRecord)
+{
+       enum Constants
+       {
+               ChunkSize = 64*1024,
+               WindowBits = 15,
+               CRC32Pos = 14
+       };
+
+       static uint8_t Header[] =
+       {
+               0x50, 0x4b, 0x03, 0x04,  // Header
+               20, // Version (2.0)
+               0, // File attributes
+               0,0, // gp flag.
+               8,0, // deflate method
+               0,0, // file time
+               0,0, // file date
+               0,0,0,0, // CRC32
+               0,0,0,0, // Compressed size
+               0,0,0,0 // Uncompressed size
+       };
+
+       zsize_t outPos(writer->getSize());
+       outRecord.localHeaderOffset = outPos;
+       outRecord.filename = filename;
+
+       // Write header
+       {
+               uint8_t buffer[ChunkSize];
+               memcpy(buffer, Header, sizeof(Header));
+               zsize_t pos(sizeof(Header));
+
+               std::string::size_type filenameSize(filename.size());
+               if (filenameSize > (ChunkSize - pos))
+               {
+                       filenameSize = ChunkSize - pos;
+               }
+               buffer[pos++] = filenameSize & 0xff;
+               buffer[pos++] = (filenameSize >> 8);
+               buffer[pos++] = 0; // extra field len
+               buffer[pos++] = 0; // extra field len
+               memcpy(buffer + pos, filename.data(), filenameSize);
+               pos += filenameSize;
+               writer->writeData(outPos, pos, &buffer[0]);
+               outPos += pos;
+       }
+
+       // Write compressed data
+
+       uint8_t inChunk[ChunkSize];
+       uint8_t outChunk[ChunkSize];
+
+       outRecord.uncompressedSize = 0;
+       outRecord.compressedSize = 0;
+
+       z_stream stream;
+       stream.zalloc = NULL;
+       stream.zfree = NULL;
+       stream.opaque = NULL;
+       int zlibErr(
+               deflateInit2(
+                       &stream,
+                       Z_DEFAULT_COMPRESSION,
+                       Z_DEFLATED,
+                       -WindowBits,
+                       MAX_MEM_LEVEL,
+                       Z_DEFAULT_STRATEGY)
+                       );
+
+       assert(zlibErr == Z_OK);
+       DeflateDeleter deleter(&stream);
+       stream.next_in = NULL;
+       stream.avail_in = 0;
+
+       zsize_t pos(0);
+       zsize_t end(reader.getSize());
+       outRecord.crc32 = crc32(0, NULL, 0);
+
+       while (pos < end)
+       {
+               if (stream.avail_in == 0)
+               {
+                       stream.avail_in =
+                               std::min(zsize_t(ChunkSize), end - pos);
+                       reader.readData(
+                               pos, stream.avail_in, &inChunk[0]);
+                       stream.next_in = reinterpret_cast<Bytef*>(&inChunk);
+                       pos += stream.avail_in;
+                       outRecord.uncompressedSize += stream.avail_in;
+                       outRecord.crc32 =
+                               crc32(outRecord.crc32, stream.next_in, stream.avail_in);
+               }
+
+               stream.next_out = reinterpret_cast<Bytef*>(&outChunk);
+               stream.avail_out = sizeof(outChunk);
+
+               zlibErr = deflate(&stream, (pos < end) ? Z_NO_FLUSH : Z_FINISH);
+
+               if (zlibErr == Z_STREAM_END)
+               {
+                       if (pos < end)
+                       {
+                               assert(!"zlib buffer unexpectedly empty");
+                               std::terminate();
+                       }
+               }
+               else if (zlibErr != Z_OK)
+               {
+                       throw FormatException("Corrupt Data");
+               }
+
+               zsize_t bytesToWrite(sizeof(outChunk) - stream.avail_out);
+               writer->writeData(
+                               outPos,
+                               bytesToWrite,
+                               &outChunk[0]);
+               outPos += bytesToWrite;
+               outRecord.compressedSize += bytesToWrite;
+       }
+
+       // Go back and complete the header.
+       uint8_t trailer[12];
+       write32(outRecord.crc32, &trailer[0]);
+       write32(outRecord.compressedSize, &trailer[4]);
+       write32(outRecord.uncompressedSize, &trailer[8]);
+       writer->writeData(
+               outRecord.localHeaderOffset + CRC32Pos, sizeof(trailer), &trailer[0]);
+}
+
+void
+zipper::zipFinalise(
+       const std::vector<ZipFileRecord>& records,
+       const WriterPtr& writer)
+{
+       enum Constants
+       {
+               ChunkSize = 64*1024
+       };
+
+       static uint8_t FileHeader[] =
+       {
+               0x50, 0x4b, 0x01, 0x02,  // Header
+               20, 0x00, // Version (2.0)
+               20, 0x00, // Version Needed to extract (2.0)
+               0,0, // gp flag.
+               8,0, // deflate method
+               0,0, // file time
+               0,0 // file date
+       };
+
+       zsize_t outPos(writer->getSize());
+       uint32_t centralDirOffset(outPos);
+
+       for (size_t i = 0; i < records.size(); ++i)
+       {
+               uint8_t buffer[ChunkSize];
+               memcpy(buffer, FileHeader, sizeof(FileHeader));
+               zsize_t pos(sizeof(FileHeader));
+
+               write32(records[i].crc32, &buffer[pos]);
+               pos += 4;
+
+               write32(records[i].compressedSize, &buffer[pos]);
+               pos += 4;
+
+               write32(records[i].uncompressedSize, &buffer[pos]);
+               pos += 4;
+
+               std::string::size_type filenameSize(records[i].filename.size());
+               if (filenameSize > (ChunkSize - pos))
+               {
+                       filenameSize = ChunkSize - pos;
+               }
+               buffer[pos++] = filenameSize & 0xff;
+               buffer[pos++] = (filenameSize >> 8);
+               buffer[pos++] = 0; // extra field len
+               buffer[pos++] = 0; // extra field len
+
+               buffer[pos++] = 0; // file comment len
+               buffer[pos++] = 0; // file comment len
+
+               buffer[pos++] = 0; // disk number
+               buffer[pos++] = 0; // disk number
+
+               buffer[pos++] = 0; // internal file attributes
+               buffer[pos++] = 0; // internal file attributes
+
+               buffer[pos++] = 0; // external file attributes
+               buffer[pos++] = 0; // external file attributes
+               buffer[pos++] = 0; // external file attributes
+               buffer[pos++] = 0; // external file attributes
+
+               write32(records[i].localHeaderOffset, &buffer[pos]);
+               pos += 4;
+
+               memcpy(buffer + pos, records[i].filename.data(), filenameSize);
+               pos += filenameSize;
+
+               writer->writeData(outPos, pos, &buffer[0]);
+               outPos += pos;
+       }
+
+       uint32_t centralDirSize(writer->getSize() - centralDirOffset);
+
+       {
+               // End-of-directory record.
+               static uint8_t EndDirectory[] =
+               {
+                       0x50, 0x4b, 0x05, 0x06,  // Header
+                       0x00, 0x00, // Disk num
+                       0x00, 0x00 // Disk with central dir
+               };
+               uint8_t buffer[ChunkSize];
+               memcpy(buffer, EndDirectory, sizeof(EndDirectory));
+               zsize_t pos(sizeof(EndDirectory));
+
+               buffer[pos++] = records.size() & 0xff; // Entries on this disk
+               buffer[pos++] = records.size() >> 8;
+               buffer[pos++] = records.size() & 0xff; // Total entries
+               buffer[pos++] = records.size() >> 8;
+
+               write32(centralDirSize, &buffer[pos]);
+               pos += 4;
+               write32(centralDirOffset, &buffer[pos]);
+               pos += 4;
+
+               buffer[pos++] = 0; // Zip comment length
+               buffer[pos++] = 0; // Zip comment length
+
+               writer->writeData(outPos, pos, &buffer[0]);
+               outPos += pos;
+       }
+}
diff --git a/Zip.hh b/Zip.hh
new file mode 100644 (file)
index 0000000..7680a61
--- /dev/null
+++ b/Zip.hh
@@ -0,0 +1,44 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "zipper.hh"
+
+#include <string>
+#include <vector>
+
+namespace zipper
+{
+       struct ZipFileRecord
+       {
+               zsize_t localHeaderOffset;
+               uint32_t crc32;
+               uint32_t compressedSize;
+               uint32_t uncompressedSize;
+               std::string filename;
+       };
+
+       void zip(
+               const std::string& filename,
+               const Reader& reader,
+               const WriterPtr& writer,
+               ZipFileRecord& outRecord);
+
+       void zipFinalise(
+               const std::vector<ZipFileRecord>& records,
+               const WriterPtr& writer);
+}
+
index 69c6c96..e37dfa4 100644 (file)
 #      You should have received a copy of the GNU General Public License
 #      along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
 
-AC_INIT([libzipper], [1.0.0], [michael@codesrc.com])
+AC_INIT([libzipper], m4_esyscmd_s([cat VERSION]), [michael@codesrc.com])
 AC_CANONICAL_HOST
 AC_CANONICAL_TARGET
 AM_INIT_AUTOMAKE([foreign])
 AC_CONFIG_HEADERS([autoconfig.h])
-AC_CONFIG_FILES([Makefile])
+AC_CONFIG_FILES([Makefile Doxyfile])
+
+AC_SUBST([libzipper_version], m4_esyscmd_s([cat VERSION]))
 
 AC_PROG_CXX
 AC_PROG_LIBTOOL
 
+DX_DOXYGEN_FEATURE([ON])
+DX_HTML_FEATURE([ON])
+DX_CHM_FEATURE(OFF)
+DX_CHI_FEATURE(OFF)
+DX_MAN_FEATURE(OFF)
+DX_RTF_FEATURE(OFF)
+DX_XML_FEATURE(OFF)
+DX_PDF_FEATURE(OFF)
+DX_PS_FEATURE(OFF)
+
+DX_INIT_DOXYGEN([libzipper], [Doxyfile], [doc])
+
 PKG_CHECK_MODULES([ZLIB], [zlib >= 1.2.3],,
        AC_MSG_ERROR([zlib 1.2.3 or newer not found.])
 )
diff --git a/doxygen.am b/doxygen.am
new file mode 100644 (file)
index 0000000..a46b5c2
--- /dev/null
@@ -0,0 +1,157 @@
+## --------------------------------- ##
+## Format-independent Doxygen rules. ##
+## --------------------------------- ##
+
+if DX_COND_doc
+
+## ------------------------------- ##
+## Rules specific for HTML output. ##
+## ------------------------------- ##
+
+if DX_COND_html
+
+DX_CLEAN_HTML = @DX_DOCDIR@/html
+
+endif DX_COND_html
+
+## ------------------------------ ##
+## Rules specific for CHM output. ##
+## ------------------------------ ##
+
+if DX_COND_chm
+
+DX_CLEAN_CHM = @DX_DOCDIR@/chm
+
+if DX_COND_chi
+
+DX_CLEAN_CHI = @DX_DOCDIR@/@PACKAGE@.chi
+
+endif DX_COND_chi
+
+endif DX_COND_chm
+
+## ------------------------------ ##
+## Rules specific for MAN output. ##
+## ------------------------------ ##
+
+if DX_COND_man
+
+DX_CLEAN_MAN = @DX_DOCDIR@/man
+
+endif DX_COND_man
+
+## ------------------------------ ##
+## Rules specific for RTF output. ##
+## ------------------------------ ##
+
+if DX_COND_rtf
+
+DX_CLEAN_RTF = @DX_DOCDIR@/rtf
+
+endif DX_COND_rtf
+
+## ------------------------------ ##
+## Rules specific for XML output. ##
+## ------------------------------ ##
+
+if DX_COND_xml
+
+DX_CLEAN_XML = @DX_DOCDIR@/xml
+
+endif DX_COND_xml
+
+## ----------------------------- ##
+## Rules specific for PS output. ##
+## ----------------------------- ##
+
+if DX_COND_ps
+
+DX_CLEAN_PS = @DX_DOCDIR@/@PACKAGE@.ps
+
+DX_PS_GOAL = doxygen-ps
+
+doxygen-ps: @DX_DOCDIR@/@PACKAGE@.ps
+
+@DX_DOCDIR@/@PACKAGE@.ps: @DX_DOCDIR@/@PACKAGE@.tag
+       cd @DX_DOCDIR@/latex; \
+       rm -f *.aux *.toc *.idx *.ind *.ilg *.log *.out; \
+       $(DX_LATEX) refman.tex; \
+       $(MAKEINDEX_PATH) refman.idx; \
+       $(DX_LATEX) refman.tex; \
+       countdown=5; \
+       while $(DX_EGREP) 'Rerun (LaTeX|to get cross-references right)' \
+               refman.log > /dev/null 2>&1 \
+                       && test $$countdown -gt 0; do \
+               $(DX_LATEX) refman.tex; \
+               countdown=`expr $$countdown - 1`; \
+       done; \
+       $(DX_DVIPS) -o ../@PACKAGE@.ps refman.dvi
+
+endif DX_COND_ps
+
+## ------------------------------ ##
+## Rules specific for PDF output. ##
+## ------------------------------ ##
+
+if DX_COND_pdf
+
+DX_CLEAN_PDF = @DX_DOCDIR@/@PACKAGE@.pdf
+
+DX_PDF_GOAL = doxygen-pdf
+
+doxygen-pdf: @DX_DOCDIR@/@PACKAGE@.pdf
+
+@DX_DOCDIR@/@PACKAGE@.pdf: @DX_DOCDIR@/@PACKAGE@.tag
+       cd @DX_DOCDIR@/latex; \
+       rm -f *.aux *.toc *.idx *.ind *.ilg *.log *.out; \
+       $(DX_PDFLATEX) refman.tex; \
+       $(DX_MAKEINDEX) refman.idx; \
+       $(DX_PDFLATEX) refman.tex; \
+       countdown=5; \
+       while $(DX_EGREP) 'Rerun (LaTeX|to get cross-references right)' \
+               refman.log > /dev/null 2>&1 \
+                       && test $$countdown -gt 0; do \
+               $(DX_PDFLATEX) refman.tex; \
+               countdown=`expr $$countdown - 1`; \
+       done; \
+       mv refman.pdf ../@PACKAGE@.pdf
+
+endif DX_COND_pdf
+
+## ------------------------------------------------- ##
+## Rules specific for LaTeX (shared for PS and PDF). ##
+## ------------------------------------------------- ##
+
+if DX_COND_latex
+
+DX_CLEAN_LATEX = @DX_DOCDIR@/latex
+
+endif DX_COND_latex
+
+.PHONY: doxygen-run doxygen-doc $(DX_PS_GOAL) $(DX_PDF_GOAL)
+
+.INTERMEDIATE: doxygen-run $(DX_PS_GOAL) $(DX_PDF_GOAL)
+
+doxygen-run: @DX_DOCDIR@/@PACKAGE@.tag
+
+doxygen-doc: doxygen-run $(DX_PS_GOAL) $(DX_PDF_GOAL)
+
+@DX_DOCDIR@/@PACKAGE@.tag: $(DX_CONFIG) $(pkginclude_HEADERS)
+       rm -rf @DX_DOCDIR@
+       $(DX_ENV) $(DX_DOXYGEN) $(DX_CONFIG)
+
+DX_CLEANFILES = \
+       @DX_DOCDIR@/@PACKAGE@.tag \
+       -r \
+       $(DX_CLEAN_HTML) \
+       $(DX_CLEAN_CHM) \
+       $(DX_CLEAN_CHI) \
+       $(DX_CLEAN_MAN) \
+       $(DX_CLEAN_RTF) \
+       $(DX_CLEAN_XML) \
+       $(DX_CLEAN_PS) \
+       $(DX_CLEAN_PDF) \
+       $(DX_CLEAN_LATEX)
+
+endif DX_COND_doc
+
diff --git a/util.hh b/util.hh
new file mode 100644 (file)
index 0000000..fbce16a
--- /dev/null
+++ b/util.hh
@@ -0,0 +1,32 @@
+//     Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
+//
+//     This file is part of libzipper.
+//
+//     libzipper is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as published by
+//     the Free Software Foundation, either version 3 of the License, or
+//     (at your option) any later version.
+//
+//     libzipper is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef zipper_util_hh
+#define zipper_util_hh
+
+namespace zipper
+{
+       template <typename T>
+       struct
+       dummy_delete
+       {
+               void operator()(T*) {}
+       };
+}
+
+#endif
+
index 323aee8..97e0667 100644 (file)
--- a/zipper.cc
+++ b/zipper.cc
 
 using namespace zipper;
 
-class BasicBuffer : public Provider, public Consumer
-{
-public:
-       BasicBuffer()
-       {
-       }
-
-       BasicBuffer(const std::vector<uint8_t>& buffer) :
-               m_buffer(buffer)
-       {
-       }
-
-       const std::vector<uint8_t>& getBuffer() const { return m_buffer; }
-
-       virtual zoff64_t zip_getSize() const { return m_buffer.size(); }
-
-       virtual void zip_readData(
-               zoff64_t offset, size_t bytes, uint8_t* dest
-               ) const
-       {
-               assert(offset + bytes <= m_buffer.size());
-               for (size_t i(0); i < bytes; ++i)
-               {
-                       dest[i] = m_buffer[offset + i];
-               }
-       }
-
-       virtual void zip_writeData(
-               size_t bytes, const uint8_t* data
-               )
-       {
-               m_buffer.insert(m_buffer.begin(), data, data + bytes);
-       }
-private:
-       std::vector<uint8_t> m_buffer;
-};
-
-
 int main()
 {
-       int fd(open("test.zip", O_RDONLY));
-
-       std::vector<uint8_t> buf(256*1024);
-       size_t bytes(::read(fd, &buf[0], buf.size()));
-       buf.resize(bytes);
-
-       std::shared_ptr<BasicBuffer> basicBuffer(
-               new BasicBuffer(buf)
-               );
-
-       Unzip unzip(basicBuffer);
-       std::vector<CompressedFilePtr> entries(unzip.getEntries());
+/*
+       FileReader reader("test.zip");
+       Decompressor decomp(reader);
+       std::vector<CompressedFilePtr> entries(decomp.getEntries());
        for (size_t f = 0; f < entries.size(); ++f)
        {
-               BasicBuffer out;
-               entries[f]->uncompress(out);
-
-               int fout(open("zipOutput", O_WRONLY | O_CREAT | O_TRUNC, 0660));
-               ::write(fout, &out.getBuffer()[0], out.getBuffer().size());
-               close(fout);
+               FileWriter writer(entries[f]->getPath(), 0660);
+               entries[f]->decompress(writer);
+       }
+*/
+       FileReader reader("test");
+       FileWriter writer("test.zip", 0660);
+       {
+               Compressor comp(Container_zip, writer);
+               comp.addFile(reader);
        }
 }
index 9cd68a6..9964e95 100644 (file)
--- a/zipper.hh
+++ b/zipper.hh
 //     You should have received a copy of the GNU General Public License
 //     along with libzipper.  If not, see <http://www.gnu.org/licenses/>.
 
+#ifndef zipper_hh
+#define zipper_hh
+
 #include <stdexcept>
 #include <memory>
 #include <string>
 #include <vector>
 
-#include <cstddef> // size_t
 #include <cstdint>
 
+#include <sys/stat.h> // For mode_t
+
+/// \mainpage libzipper C++ (de)compression library
+///
+/// \section intro Introduction
+/// libzipper offers a flexible C++ interface for reading compressed files
+/// in multiple formats.
+///
+/// <a href="http://www.codesrc.com/src/libzipper">Homepage</a>
+///
+/// libzipper aims to provide applications a transparent method of accessing
+/// compressed data. eg. libzipper is suited to reading XML config files that
+/// are compressed to save space.
+///
+/// libzipper is not a general-purpose archive management library, as it
+/// does not provide access to the filesystem attributes of each file.
+/// (ie. libzipper does not support the concepts of file owner, group,
+/// permissions, or timestamps.
+///
+/// \section formats Supported Formats
+/// <ul>
+///   <li>zip</li>
+/// </ul>
+///
+/// \section example_read Reading a compressed file into memory
+///
+/// \code
+/// #include <zipper.hh>
+/// #include <algorithm>
+/// #include <vector>
+///
+/// class MemWriter : public zipper::Writer
+/// {
+/// public:
+///            std::vector<uint8_t> data;
+///            virtual void writeData(
+///                    zsize_t offset, zsize_t bytes, const uint8_t* inData)
+///            {
+///         data.resize(std::max(offset + bytes, data.size()));
+///                    std::copy(inData, inData + bytes, &data[offset]);
+///            }
+///            virtual zsize_t getSize() const { return data.size(); }
+/// };
+///
+/// std::vector<uint8_t> readSavedGame(const std::string& filename)
+/// {
+///            // open the compressed input file. FileReader will throw an
+///            // exception if an IO error occurs.
+///            zipper::FileReader reader(filename);
+///
+///            MemWriter writer;
+///
+///            zipper::Decompressor decomp(reader);
+///
+///            std::vector<zipper::CompressedFilePtr> entries(decomp.getEntries());
+///
+///            if (!entries.empty())
+///            {
+///                    // Uncompress the first file. Will pass-though data as-is if the
+///                    // file is not compressed.
+///                    entries.front()->decompress(writer);
+///            }
+///            return writer.data;
+///    }
+///
+/// \endcode
+///
+/// \section example_write Writing compressed files.
+/// \code
+/// #include <zipper.hh>
+/// #include <algorithm>
+/// #include <vector>
+///
+/// class MemReader : public zipper::Reader
+/// {
+/// public:
+///            MemReader(const vector<uint8_t>& data) : m_data(data) {}
+///
+///            virtual const std::string& getSourceName() const
+///     {
+///         static std::string Name("savedGame.dat");
+///         return Name;
+///     }
+///
+///            virtual zsize_t getSize() const { return m_data.size(); }
+///
+///            virtual void readData(
+///                    zsize_t offset, zsize_t bytes, uint8_t* dest
+///         ) const
+///            {
+///                    std::copy(&m_data[offset], &m_data[offset + bytes], dest);
+///            }
+///    private:
+///            std::vector<uint8_t> m_data;
+/// };
+///
+/// void writeSavedGame(
+///            const std::string& filename, const std::vector<uint8_t>& gameData
+///            )
+/// {
+///            zipper::FileWriter writer(filename);
+///            zipper::Compressor comp(zipper::Container_zip, writer);
+///            comp.addFile(MemReader(gameData));
+///    }
+///
+/// \endcode
 
+/// \namespace zipper
+/// \brief The zipper namespace contains the libzipper public API.
 namespace zipper
 {
-       typedef uint64_t zoff64_t;
+       /// \typedef zsize_t
+       /// zsize_t should be used exclusively when dealing with file offsets
+       /// and sizes to support large files (>4Gb).
+       ///
+       /// Unlike size_t on some systems, zsize_t will be 64bit when compiling for
+       /// a 32bit target.
+       typedef uint64_t zsize_t;
+
+       /// \enum ContainerFormat
+       /// ContainerFormat enumerates the compressed archive formats supported
+       /// by libzipper.
+       ///
+       /// An application can determine the supported formats by iterating
+       /// over the Container_begin to Container_end range. eg.
+       /// \code
+       /// for (int i = Container_begin; i < Container_end; ++i)
+       /// {
+       ///     const Container& container(getContainer(ContainerFormat(i)));
+       /// }
+       /// \endcode
+       enum ContainerFormat
+       {
+               /// Iteration marker
+               Container_begin = 0,
+
+               /// No container (eg. plain text)
+               Container_none = 0,
+
+               /// ZIP
+               Container_zip,
+
+               /// gzip.
+               Container_gzip,
+
+               /// Iteration marker
+               Container_end
+       };
 
-       class ZipException : public std::runtime_error
+       /// \struct Container
+       /// Provides libzipper capability details for a compressed archive
+       /// format.
+       /// \see getContainer
+       struct Container
+       {
+               /// \enum CapabilityBits allows a bitmask to be specified with a
+               /// combination of boolean flags.
+               enum CapabilityBits
+               {
+                       /// Compression bit is set if the format is usable with Compressor
+                       Compression = 1,
+
+                       /// Decompression bit is set if the format is usable with
+                       /// Decompressor
+                       Decompression = 2,
+
+                       /// EmbeddedFilenames bit is set if CompressedFile::getPath() is
+                       /// supported
+                       EmbeddedFilenames = 4,
+
+                       /// Archive bit is set if multiple compressed files may exist in
+                       /// a single container.
+                       Archive = 8,
+
+                       /// FileSize bit is set if the uncompressed size for each
+                       /// compressed file is recorded in the container.
+                       FileSize = 16
+               };
+
+               /// %Container Type
+               ContainerFormat format;
+
+               /// %Container Internet Media Type (aka MIME type).
+               /// eg. "application/zip"
+               std::string mediaType;
+
+               /// Bitmask comprised of CapabilityBits enum values.
+               uint32_t capabilities;
+       };
+
+       /// \brief Returns the capability details of the given format.
+       const Container& getContainer(ContainerFormat format);
+
+       /// \brief Base class for all exceptions thrown by libzipper
+       class Exception : public std::runtime_error
        {
        public:
-               ZipException(const std::string& what);
+               /// Exception ctor
+               /// \param what A description of the error encountered.
+               Exception(const std::string& what);
        };
 
-       class ZipFormatException : public ZipException
+       /// \brief Exception thrown when the input data does not match
+       /// the expected Container format.
+       class FormatException : public Exception
        {
        public:
-               ZipFormatException(const std::string& what);
+               /// FormatException ctor
+               /// \param what A description of the error encountered.
+               FormatException(const std::string& what);
        };
 
-       class ZipUnsupportedException : public ZipException
+       /// \brief Exception thrown when a Reader or Writer instance is unable
+       /// to satisfy an IO request due to an external error.
+       class IOException : public Exception
        {
        public:
-               ZipUnsupportedException(const std::string& what);
+               /// IOException ctor
+               /// \param what A description of the error encountered.
+               IOException(const std::string& what);
        };
 
-       class Provider
+       /// \brief Exception thrown when an operation is requested on a compressed
+       /// archive that libzipper does not implement.
+       ///
+       /// This exception may be thrown even if libzipper advertises general
+       /// support for the Container format.  eg. libzipper supports most
+       /// ZIP files, but an UnsupportedException will be thrown if given an
+       /// encrypted ZIP file.
+       class UnsupportedException : public Exception
        {
        public:
-               virtual ~Provider();
+               /// UnsupportedException ctor
+               /// \param what A description of the error encountered.
+               UnsupportedException(const std::string& what);
+       };
 
-               virtual zoff64_t zip_getSize() const = 0;
+       /// \brief Reader supplies input data to the compression/decompression
+       /// functions.
+       ///
+       /// Normally, an application using libzipper provides the Reader
+       /// implementation. The implementation could supply data from files,
+       /// in-memory buffers, or it could be generated on-the-fly.
+       ///
+       /// The Reader implementation must support random access, and must
+       /// determine at creation time the number of bytes available. The
+       /// Reader interface is not suitable for use with streaming data.
+       class Reader
+       {
+       public:
+               /// Reader dtor
+               virtual ~Reader();
 
-               virtual void zip_readData(
-                       zoff64_t offset, size_t bytes, uint8_t* dest
+               /// Returns a name for this source of the data.
+               ///
+               /// For file-based Reader implementations, this would normally be
+               /// the input filename.
+               virtual const std::string& getSourceName() const = 0;
+
+               /// Returns the number of bytes available via readData()
+               ///
+               /// \invariant getSize() is stable throughout the lifetime
+               /// of the Reader instance.
+               virtual zsize_t getSize() const = 0;
+
+               /// Copies data into the dest buffer
+               ///
+               /// An exception must be thrown if it is not possible to copy the
+               /// requested data into the supplied buffer (eg. file IO error).
+               ///
+               /// \pre offset + bytes <= getSize()
+               ///
+               /// \param offset Number of bytes to skip at the front of the data
+               /// source.
+               /// \param bytes Number of bytes to copy
+               /// \param dest Destination buffer.
+               ///
+               virtual void readData(
+                       zsize_t offset, zsize_t bytes, uint8_t* dest
                        ) const = 0;
        };
-       typedef std::shared_ptr<Provider> ProviderPtr;
 
-       class Consumer
+       /// \brief FileReader is a file-based implementation of the Reader
+       /// interface.
+       class FileReader : public Reader
        {
        public:
-               virtual ~Consumer();
+               /// Read data from the supplied file.
+               FileReader(const std::string& filename);
+
+               /// Read data from the supplied file.
+               ///
+               /// \param filename The value used by getSourceName(). This name
+               /// is arbitary, and does not need to be related to fd.
+               ///
+               /// \param fd The descriptor to source data from.  The descriptor
+               /// must be open for reading, blocking, and seekable (ie. lseek(2)).
+               ///
+               /// \param closeFd If true, fd will be closed by this object
+               /// when it is no longer needed.
+               FileReader(const std::string& filename, int fd, bool closeFd);
+
+               /// FileReader dtor
+               virtual ~FileReader();
 
-               virtual void zip_writeData(
-                       size_t bytes, const uint8_t* data
+               /// Inherited from Reader
+               virtual const std::string& getSourceName() const;
+
+               /// Inherited from Reader
+               virtual zsize_t getSize() const;
+
+               /// Inherited from Reader
+               virtual void readData(
+                       zsize_t offset, zsize_t bytes, uint8_t* dest
+                       ) const;
+       private:
+               FileReader(const FileReader&);
+               FileReader& operator=(const FileReader&);
+
+               class FileReaderImpl;
+               FileReaderImpl* m_impl;
+       };
+
+       /// \typedef ReaderPtr
+       /// A shared pointer to a Reader
+       typedef std::shared_ptr<Reader> ReaderPtr;
+
+       /// \brief Writer accepts output data from the compression/decompression
+       /// functions.
+       ///
+       /// Normally, an application using libzipper provides the Writer
+       /// implementation. The implementation could write data to files,
+       /// in-memory buffers, or it could be simply discarded.
+       ///
+       /// The Writer implementation needs only to support sequential access.
+       class Writer
+       {
+       public:
+               /// Writer dtor
+               virtual ~Writer();
+
+               /// Returns the size of the written data.
+               virtual zsize_t getSize() const = 0;
+
+               /// Accepts output from libzipper
+               ///
+               /// An exception must be thrown if it is not possible to accept
+               /// given data. (eg. file IO error).
+               ///
+               /// \param offset Number of bytes to skip at the front of the data
+               /// source.  Skipped bytes will contain null characters if not already
+               /// assigned a value.
+               /// \param bytes Number of bytes in data
+               /// \param data Output from libzipper.
+               ///
+               virtual void writeData(
+                       zsize_t offset, zsize_t bytes, const uint8_t* data
                        ) = 0;
        };
 
+       /// \typedef WriterPtr
+       /// A shared pointer to a Writer
+       typedef std::shared_ptr<Writer> WriterPtr;
+
+       /// \brief FileWrter is a file-based implementation of the Writer
+       /// interface.
+       class FileWriter : public Writer
+       {
+       public:
+               /// Write data to the supplied file.
+               /// If the file already exists, it will be truncated.
+               /// If the file does not exist, it will be created with the
+               /// given permissions.
+               ///
+               /// \param filename The file to open for writing.
+               ///
+               /// \param createPermissions The permissions set on the file if it is to
+               /// be created.
+               FileWriter(const std::string& filename, mode_t createPermissions);
+
+               /// Write data to the supplied file.
+               ///
+               /// \param filename The filename reported in any exception error
+               /// messages. This name  is arbitary, and does not need to be
+               /// related to fd.
+               ///
+               /// \param fd The descriptor to write data to.  The descriptor
+               /// must be open for writing in blocking mode.
+               ///
+               /// \param closeFd If true, fd will be closed by this object
+               /// when it is no longer needed.
+               FileWriter(const std::string& filename, int fd, bool closeFd);
+
+               /// FileWriter dtor
+               virtual ~FileWriter();
+
+               /// Inherited from Writer
+               virtual zsize_t getSize() const;
+
+               /// Inherited from Writer
+               virtual void writeData(
+                       zsize_t offset, zsize_t bytes, const uint8_t* data
+                       );
+       private:
+               FileWriter(const FileWriter&);
+               FileWriter& operator=(const FileWriter&);
+
+               class FileWriterImpl;
+               FileWriterImpl* m_impl;
+       };
+
+       /// \brief CompressedFile represents an entry within a compressed archive.
+       ///
+       /// CompressedFile instances are created by Decompressor, and allow
+       /// selectively extracting the contents of an archive.
        class CompressedFile
        {
        public:
+               /// CompressedFile dtor
                virtual ~CompressedFile();
-               virtual bool isValid() const = 0;
-               virtual void uncompress(Consumer& consumer) = 0;
+
+               /// Return true if decompress is likely to succeed.
+               ///
+               /// isDecompressSupported may return false if libzipper doesn't know
+               /// how to deal with the compressed data. eg. encrypted files,
+               /// or ZIP files compressed with non-standard schemes.
+               virtual bool isDecompressSupported() const = 0;
+
+               /// Decompress the file, and store the results via the given
+               /// writer object.
+               virtual void decompress(Writer& writer) = 0;
+
+               /// Return the file path of the compressed file.
+               ///
+               /// Unix-style path separaters ('/') are returned, even if the
+               /// archive was created under an alternative OS.
+               virtual const std::string& getPath() const = 0;
+
+               /// Return the compressed size of the file
+               ///
+               /// getCompressedSize() will return -1 of the FileSize capability
+               /// bit of the container is false.
+               virtual zsize_t getCompressedSize() const = 0;
+
+               /// Return the uncompressed size of the file
+               ///
+               /// The decompress method will pass exactly this number of bytes
+               /// to the Writer.
+               ///
+               /// getUncompressedSize() will return -1 of the FileSize capability
+               /// bit of the container is false.
+               virtual zsize_t getUncompressedSize() const = 0;
        };
+       /// \typedef CompressedFilePtr
+       /// A shared pointer to a CompressedFile
        typedef std::shared_ptr<CompressedFile> CompressedFilePtr;
 
-// NO! Rename to Decompress. We want this to work for -any- container!
-// bz2, tar, iso, gz, rar
-// Similarly, rename the exceptions.
-       class Unzip
+       /// \brief Decompressor detects the compressed archive type of the data,
+       /// and creates suitable CompressedFile instances to access the compressed
+       /// data.
+       class Decompressor
        {
        public:
-               Unzip(const ProviderPtr& provider);
-               ~Unzip();
+               /// Create a decompressor from the data made available by reader.
+               Decompressor(const ReaderPtr& reader);
+
+               /// Create a decompressor from the data made available by reader.
+               ///
+               /// \param reader must remain in scope for the lifetime of the
+               /// Decompressor, and lifetime of any CompressedFile objects returned
+               /// from getEntries()
+               Decompressor(Reader& reader);
+
+               /// Decompressor dtor
+               ~Decompressor();
+
+               /// Return the detected Container type of the compressed archive.
+               ContainerFormat getContainerFormat() const;
 
+               /// Return CompressedFile entries to represent the file entries within
+               /// a compressed archive.
                std::vector<CompressedFilePtr> getEntries() const;
        private:
-               class UnzipImpl;
-               UnzipImpl* m_unzipper;
+               Decompressor(const Decompressor&);
+               Decompressor& operator=(const Decompressor&);
+
+               class DecompressorImpl;
+               DecompressorImpl* m_decompressor;
+       };
+
+       /// \brief Compressor creates a compressed archive from the supplied
+       /// Reader objects.
+       /// data.
+       class Compressor
+       {
+       public:
+               /// Create a Compressor to output the given compressed archived format
+               /// to writer.
+               Compressor(ContainerFormat format, const WriterPtr& writer);
+
+               /// Create a Compressor to output the given compressed archived format
+               /// to writer.
+               ///
+               /// \param writer must remain in scope for the lifetime of the
+               /// Compressor.
+               Compressor(ContainerFormat format, Writer& writer);
+
+               /// \brief Compressor dtor
+               ///
+               /// Additional data may be passed to writer (given in ctor) to close
+               /// the compressed archive.
+               ~Compressor();
+
+               /// Compress the data given by reader, and add it to the compressed
+               /// archive.
+               void addFile(const Reader& reader);
+
+               class CompressorImpl;
+       private:
+               Compressor(const Compressor&);
+               Compressor& operator=(const Compressor&);
+
+               CompressorImpl* m_compressor;
        };
 }
 
+#endif
+