chmxx.h

It is a chm file viewer lib with source code

#ifndef __chm_h__
#define __chm_h__

#include <string>
#include <ostream>
#include <istream>
#include <vector>
#include <list>
#include <map>

/**
 * @mainpage
 * This is a c++ library for accessing the Microsoft(TM)
 * help files (mostly .chm files).<br> For latest updates
 * and more information please see<br>
 *      <ul>http://www.mare.ee/indrek/libchmxx/</ul>
 */


struct chmFile;

/** This is the namespace for libchmxx library.
  * The library should not export any sumbols to global
  * namespace.
  */
namespace chm {

/** This represents a tree of topics with titles and paths. */
struct chm_topics_tree {
  std::string title;  ///< Title of the tree node
  std::string path;   ///< Path to file under given topic or empty
  chm_topics_tree *parent; ///< Pointer to parent tree node, NULL if no parent
  std::list<chm_topics_tree *> children; ///< std::list of children node

  ~chm_topics_tree ();
};

/** Matched document inside the search result. */
struct chm_search_document {
  std::string title;                ///< Document title.
  std::string path;                 ///< Document path.
  std::vector<int> offsets;         ///< Where inside this document the result was found
};

/** Search match for keyword found inside the index. */
struct chm_search_match {
  int is_title;                    ///< Given key is inside a title
  std::string key;                  ///< Key that was found inside the index.
  std::vector<chm_search_document> documents; ///< Documents matching to this index.
};

/** A chm archive. */
class chmfile {
public:
  /** Construct a new chmfile object from given path. */
  chmfile (const std::string& path);
  virtual ~chmfile ();

  /** Tests whether archive is valid and open. */
  bool is_open () const;

  /** Close the archive and free resources. */
  void close ();

  /** Tests whether opened archive is valid. */
  inline operator bool() const { return is_open(); }

  /** Read the entire contents of given file and write to stream out. */
  bool read (const std::string& path, std::ostream& out) const;

  /** Read the entire contents of a file and store inside given vector.
   * The vector is resized to file size. */
  bool read (const std::string& path, std::vector<char>& out) const;

  /** Read buf_size bytes from path and place into buf. */
  bool read (const std::string& path, char *buf, size_t buf_size) const;

  /** Returns the size of given file inside archive, returns 0 if file does not exist. */
  std::streamsize file_size (const std::string& path) const;

  /** Returns a boolean value whether given file exists inside the archive. */
  bool file_exists (const std::string& path) const;

  /** Use a combination of these as argument to the readdir. */
  enum readdir_type { files = 1, dirs = 2, special = 4, meta = 8 };

  /** Read entries under given path and append them to the list.
    * Files of directory type will have '/' at the end of their names. */
  bool readdir (const std::string& path, std::list<std::string>& entries, int type = files|dirs) const;

  /** Open given path inside the archive for reading and return a streambuf object.
    * Returns 0 in case file does not exist or an error happened. You're
    * better off to using chmistream than this method. The returned object should
    * be deleted after use. */
  std::streambuf* open (const std::string& path, size_t buf_size = 1024) const;

  inline const std::string& get_title () const { return title; }
  inline const std::string& get_home_file () const { return home_file; }
  inline const std::string& get_generator () const { return generator; }
  inline const std::string& get_index_file () const { return index_file; }
  inline const std::string& get_topics_file () const { return topics_file; }
  inline const std::string& get_path () const { return path; }

  /** Gets the topics tree. If this is called first time the tree
    * is calculated and stored for later use. In case the chm file
    * has no soptics tree NULL is returned. */
  const chm_topics_tree * get_topics_tree () const;

  /** Search the archive for given keyword and return found entries in found. */
  bool search_index (const std::string& txt, std::list<chm_search_match>& found,
      bool whole_words = true, bool titles_only = true) const;

  /** Cache given file for _fast_ access inside memory. All streams opened
    * for that file will be memory cached. I know this caching business
    * is a bit superfluous. It's not all good too - if you start
    * unreading stuff using the stream the cache will be changed.
    */
  bool cache (const std::string& path);
  /** Cache all metadata that is required to perform fast searches inside the index. */
  void cache_search_database ();

private:
  mutable chmFile *chm;
  std::string path;

  std::string title, home_file, generator, index_file, topics_file;

  mutable chm_topics_tree *tree;

  chmfile (const chmfile&);
  chmfile& operator= (const chmfile&);

  typedef std::map<std::string,std::vector<char> > cache_data_t;
  cache_data_t cache_data;
};

/** Inputstream for reading files inside a chm archives.
  * @code
        chm::chmfile chm("/chmfile.chm");
        chm::chmistream in(chm, "/path");
        string line;
        while ( readline(chm, line) ) {
            cout << line;
        }
  * @endcode
  */
class chmistream : public std::istream {
public:
  /** Create a new input stream from archive for given path. */
  chmistream (const chmfile& chm, const std::string& path, size_t buf_size = 1024);

  /** Returns the number of bytes that are left to be read from this stream.
   * So returns the size of file when nothing has been read. */
  std::streamsize read_left () const;

  virtual ~chmistream ();

  /** Get little endian MS encint from the stream. */
  inline size_t get_encint()
  {
      size_t result = 0;
      int shift = 0;

      while (1) {
          int n = get();
          result |= (n & 0x7f) << shift;
          shift += 7;
          if ( !(n & 0x80) ) break;
      };

      return result;
  }

  /** Get local endianized MS dword (2 x 2 bytes) from the stream. */
  inline unsigned long get_dword ()
  {
#if __BYTE_ORDER == __LITTLE_ENDIAN // convenience shortcut
    unsigned long res = 0;  // long guatanteed to be 4 bytes
    read ((char *)&res, 4);
    return res;
#else
    char buf[4];
    read (buf, 4);
    size_t res = buf[0];
    res |= buf[1] << 8;
    res |= buf[2] << 16;
    res |= buf[3] << 24;
    return res;
#endif
  }

  /** Get local endianized MS word (2 bytes) from the stream.
    */
  inline unsigned int get_word ()
  {
#if __BYTE_ORDER == __LITTLE_ENDIAN // convenience shortcut
    unsigned int res = 0;   // int guaranteed to be 2 bytes
    read ((char *)&res, 2);
    return res;
#else
    char buf[2];
    read (buf, 2);
    unsigned int res = buf[0];
    res |= buf[1] << 8;
    return res;
#endif
  }

  /** Get a s-r encoded value from the stream. Scale must alwqays be 2.
    * Use 0 for initial pos. When finished reading an entry of sr-s
    * call the get_sr_finish(pos).*/
  inline unsigned long get_sr (int s, int r, int& pos)
  {
    int b = peek();
    int p = 0;
    while ( (1 << pos) & b ) {
        p++;
        pos++;
        if ( pos == 8 ) {
            get();
            b = peek ();
            pos = 0;
        }
    }

    pos++;    // skip the 0 of p
    if ( pos == 8 ) {
        get ();
        b = peek ();
        pos = 0;
    }

    if ( p > 1 ) r += p - 1; // r now has number of bits for q

    unsigned long res = 0;

    for ( int i = 0; i < r; i++ ) {
        res |= ((1 << pos) & b) ? (1 << i) : 0;
        pos++;
        if ( pos == 8 ) {
            get ();
            b = peek ();
            pos = 0;
        }
    }

    res |= 1 << r;

    return res;
  }

  inline void get_sr_finish (int &pos)
  {
    if ( pos ) {
        get();
        pos = 0;
    }
  }

private:
  std::streambuf *buf;
  bool release;
};

}

#endif // __chm_h__