chmxx.h

Go to the documentation of this file.

#ifndef __chm_h__
#define __chm_h__

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

struct chmFile;

namespace chm {

struct chm_topics_tree {
  std::string title;  
  std::string path;   
  chm_topics_tree *parent; 
  std::list<chm_topics_tree *> children; 

  ~chm_topics_tree ();
};

struct chm_search_document {
  std::string title;                
  std::string path;                 
  std::vector<int> offsets;         
};

struct chm_search_match {
  int is_title;                    
  std::string key;                  
  std::vector<chm_search_document> documents; 
};

class chmfile {
public:
  chmfile (const std::string& path);
  virtual ~chmfile ();

  bool is_open () const;

  void close ();

  inline operator bool() const { return is_open(); }

  bool read (const std::string& path, std::ostream& out) const;

  bool read (const std::string& path, std::vector<char>& out) const;

  bool read (const std::string& path, char *buf, size_t buf_size) const;

  std::streamsize file_size (const std::string& path) const;

  bool file_exists (const std::string& path) const;

  enum readdir_type { files = 1, dirs = 2, special = 4, meta = 8 };

  bool readdir (const std::string& path, std::list<std::string>& entries, int type = files|dirs) const;

  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; }

  const chm_topics_tree * get_topics_tree () const;

  bool search_index (const std::string& txt, std::list<chm_search_match>& found,
      bool whole_words = true, bool titles_only = true) const;

  bool cache (const std::string& path);
  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;
};

class chmistream : public std::istream {
public:
  chmistream (const chmfile& chm, const std::string& path, size_t buf_size = 1024);

  std::streamsize read_left () const;

  virtual ~chmistream ();

  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;
  }

  inline unsigned long get_dword ()
  {
    char buf[4];
    read (buf, 4);
    size_t res = 0;
    res |= (unsigned char)buf[0] << 0;
    res |= (unsigned char)buf[1] << 8;
    res |= (unsigned char)buf[2] << 16;
    res |= (unsigned char)buf[3] << 24;
    return res;
  }

  inline unsigned int get_word ()
  {
    char buf[2];
    read (buf, 2);
    unsigned int res = 0;
    res |= (unsigned char)buf[0] << 0;
    res |= (unsigned char)buf[1] << 8;
    return res;
  }

  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__

---

Copyright © 2003, 2008 Indrek Mandre