xvilla.h

harvest是一个下载html网页得机器人

/*************************************************************************************************
 * C++ API of Villa, the advanced API of QDBM
 *                                                      Copyright (C) 2000-2003 Mikio Hirabayashi
 * This file is part of QDBM, Quick Database Manager.
 * QDBM is free software; you can redistribute it and/or modify it under the terms of the GNU
 * Lesser General Public License as published by the Free Software Foundation; either version
 * 2.1 of the License or any later version.  QDBM 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 Lesser General Public License for more
 * details.
 * You should have received a copy of the GNU Lesser General Public License along with QDBM; if
 * not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307 USA.
 *************************************************************************************************/


#ifndef _XVILLA_H                        /* duplication check */
#define _XVILLA_H


#include <xqdbm.h>
#include <xadbm.h>

extern "C" {
#include <depot.h>
#include <cabin.h>
#include <villa.h>
#include <stdlib.h>
}



/**
 * Error container for Villa.
 */
class qdbm::Villa_error : public virtual DBM_error {
  //----------------------------------------------------------------
  // public member functions
  //----------------------------------------------------------------
public:
  /**
   * Create an instance.
   */
  Villa_error() throw();
  /**
   * Create an instance.
   * @param ecode the error code.
   */
  Villa_error(int ecode) throw();
  /**
   * Copy constructor.
   * @param ve a source instance.
   */
  Villa_error(const Villa_error& ve) throw();
  /**
   * Release resources of the instance.
   */
  virtual ~Villa_error() throw();
  /**
   * Assignment operator.
   * @param ve a source instance.
   * @return reference to itself.
   */
  Villa_error& operator =(const Villa_error& ve) throw();
  /**
   * Assignment operator.
   * @param ecode the error code.
   * @return reference to itself.
   */
  Villa_error& operator =(int ecode) throw();
  /**
   * Equality operator.
   * @param ve a comparing instance.
   * @return true if the both equal, else, false.
   */
  virtual bool operator ==(const Villa_error& ve) const throw();
  /**
   * Inequality operator.
   * @param ve a comparing instance.
   * @return true if the both do not equal, else, false.
   */
  virtual bool operator !=(const Villa_error& ve) const throw();
  /**
   * Equality operator.
   * @param ecode a comparing error code.
   * @return true if the both equal, else, false.
   */
  virtual bool operator ==(int ecode) const throw();
  /**
   * Inequality operator.
   * @param ecode a comparing error code.
   * @return true if the both do not equal, else, false.
   */
  virtual bool operator !=(int ecode) const throw();
  /**
   * Cast operator into pointer to char.
   * @return the pointer to the string.
   */
  virtual operator const char*() const throw();
  /**
   * Get the error code.
   * @return the error code.
   */
  virtual int code() const throw();
  /**
   * Get the error message.
   * @return the pointer to the string.
   */
  virtual const char* message() const throw();
  //----------------------------------------------------------------
  // private member variables
  //----------------------------------------------------------------
private:
  /** The error code. */
  int ecode;
};



/**
 * C++ API of Villa, the basic API of QDBM.
 */
class qdbm::Villa : public virtual ADBM {
  //----------------------------------------------------------------
  // public static member constants
  //----------------------------------------------------------------
public:
  static const int ENOERR;            ///< error code: no error
  static const int EFATAL;            ///< error code: with fatal error
  static const int EMODE;             ///< error code: invalid mode
  static const int EBROKEN;           ///< error code: broken database file
  static const int EKEEP;             ///< error code: existing record
  static const int ENOITEM;           ///< error code: no item found
  static const int EALLOC;            ///< error code: memory allocation error
  static const int EMAP;              ///< error code: memory mapping error
  static const int EOPEN;             ///< error code: open error
  static const int ECLOSE;            ///< error code: close error
  static const int ETRUNC;            ///< error code: trunc error
  static const int ESYNC;             ///< error code: sync error
  static const int ESTAT;             ///< error code: stat error
  static const int ESEEK;             ///< error code: seek error
  static const int EREAD;             ///< error code: read error
  static const int EWRITE;            ///< error code: write error
  static const int ELOCK;             ///< error code: lock error
  static const int EUNLINK;           ///< error code: unlink error
  static const int EMKDIR;            ///< error code: mkdir error
  static const int ERMDIR;            ///< error code: rmdir error
  static const int EMISC;             ///< error code: miscellaneous error
  static const int OREADER;           ///< open mode: open as a reader
  static const int OWRITER;           ///< open mode: open as a writer
  static const int OCREAT;            ///< open mode: writer creating
  static const int OTRUNC;            ///< open mode: writer truncating
  static const int ONOLCK;            ///< open mode: open without locking
  static const int DOVER;             ///< write mode: overwrite the existing value
  static const int DKEEP;             ///< write mode: keep the existing value
  static const int DDUP;              ///< write mode: concatenate values
  static const int JFORWARD;          ///< jump mode: step forward
  static const int JBACKWARD;         ///< jump mode: step backward
  //----------------------------------------------------------------
  // public static member functions
  //----------------------------------------------------------------
public:
  /**
   * Get the version information.
   * @return the string of the version information.
   */
  static const char* version() throw();
  /**
   * Remove a database directory.
   * @param name the name of a database directory.
   * @throw Villa_error if an error occures.
   */
  static void remove(const char* name) throw(Villa_error);
  /**
   * Compare keys of two records by lexical order.
   * @param aptr the pointer to the region of one key.
   * @param asiz the size of the region of one key.
   * @param bptr the pointer to the region of the other key.
   * @param bsiz the size of the region of the other key.
   * @return positive if the former is big, negative if the latter is big, 0 if both are
   * equivalent.
   */
  static int cmplex(const char *aptr, int asiz, const char *bptr, int bsiz) throw();
  /**
   * Compare keys of two records as integers.
   * @param aptr the pointer to the region of one key.
   * @param asiz the size of the region of one key.
   * @param bptr the pointer to the region of the other key.
   * @param bsiz the size of the region of the other key.
   * @return positive if the former is big, negative if the latter is big, 0 if both are
   * equivalent.
   */
  static int cmpint(const char *aptr, int asiz, const char *bptr, int bsiz) throw();
  /**
   * Compare keys of two records as numbers of big endian.
   * @param aptr the pointer to the region of one key.
   * @param asiz the size of the region of one key.
   * @param bptr the pointer to the region of the other key.
   * @param bsiz the size of the region of the other key.
   * @return positive if the former is big, negative if the latter is big, 0 if both are
   * equivalent.
   */
  static int cmpnum(const char *aptr, int asiz, const char *bptr, int bsiz) throw();
  /**
   * Compare keys of two records as decimal strings.
   * @param aptr the pointer to the region of one key.
   * @param asiz the size of the region of one key.
   * @param bptr the pointer to the region of the other key.
   * @param bsiz the size of the region of the other key.
   * @return positive if the former is big, negative if the latter is big, 0 if both are
   * equivalent.
   */
  static int cmpdec(const char *aptr, int asiz, const char *bptr, int bsiz) throw();
  //----------------------------------------------------------------
  // public member functions
  //----------------------------------------------------------------
public:
  /**
   * Get the database handle.
   * @param name the name of a database file.
   * @param omode the connection mode: `Villa::OWRITER' as a writer, `Villa::OREADER' as
   * a reader.  If the mode is `Villa::OWRITER', the following may be added by bitwise or:
   * `Villa::OCREAT', which means it creates a new database if not exist, `Villa::OTRUNC',
   * which means it creates a new database regardless if one exists.  Both of `Villa::OREADER'
   * and `Villa::OWRITER' can be added to by bitwise or: `Villa::ONOLCK', which means it opens a
   * database file without file locking.
   * @param cmp the comparing function: `Villa::cmplex' comparing keys in lexical order,
   * `Villa::cmpint' comparing keys as objects of `int' in native byte order, `Villa::cmpnum'
   * comparing keys as numbers of big endian, `Villa::cmpdec' comparing keys as decimal strings.
   * Any function compatible with them can be assigned to the comparing function.  The comparing
   * function should be kept same in the life of a database.
   * @throw Villa_error if an error occures.
   * @note While connecting as a writer, an exclusive lock is invoked to the database file.
   * While connecting as a reader, a shared lock is invoked to the database file.  The thread
   * blocks until the lock is achieved.  If `Villa::ONOLCK' is used, the application is
   * responsible for exclusion control.
   */
  Villa(const char* name, int omode = Villa::OREADER, VLCFUNC cmp = Villa::cmplex)
    throw(Villa_error);
  /**
   * Release the resources.
   * @note If the database handle is not closed yet, it is closed.
   */
  virtual ~Villa() throw();
  /**
   * Close the database handle.
   * @throw Villa_error if an error occures.
   * @note Updating a database is assured to be written when the handle is closed.  If a writer
   * opens a database but does not close it appropriately, the database will be broken.  If the
   * transaction is activated and not committed, it is aborted.
   */
  virtual void close() throw(Villa_error);
  /**
   * Store a record.
   * @param kbuf the pointer to the region of a key.
   * @param ksiz the size of the region of the key.  If it is negative, the size is assigned
   * with `std::strlen(kbuf)'.
   * @param vbuf the pointer to the region of a value.
   * @param vsiz the size of the region of the value.  If it is negative, the size is assigned
   * with `std::strlen(vbuf)'.
   * @param dmode behavior when the key overlaps, by the following values: `Villa::DOVER',
   * which means the specified value overwrites the existing one, `Villa::DKEEP', which means
   * the existing value is kept, `Villa::DDUP', which means duplication of keys is allowed.
   * @throw Villa_error if an error occures or replace is cancelled.
   * @note A duplicated record is stored at the tail of the records of the same key.  The