build_vxworks/db_cxx.h

   1 /* DO NOT EDIT: automatically built by dist/s_vxworks. */
   2 /*-
   3  * See the file LICENSE for redistribution information.
   4  *
   5  * Copyright (c) 1997, 2012 Oracle and/or its affiliates.  All rights reserved.
   6  *
   7  * $Id$
   8  */
   9
  10 #ifndef _DB_CXX_H_
  11 #define _DB_CXX_H_
  12 //
  13 // C++ assumptions:
  14 //
  15 // To ensure portability to many platforms, both new and old, we make
  16 // few assumptions about the C++ compiler and library.  For example,
  17 // we do not expect STL, templates or namespaces to be available.  The
  18 // "newest" C++ feature used is exceptions, which are used liberally
  19 // to transmit error information.  Even the use of exceptions can be
  20 // disabled at runtime, to do so, use the DB_CXX_NO_EXCEPTIONS flags
  21 // with the DbEnv or Db constructor.
  22 //
  23 // C++ naming conventions:
  24 //
  25 //  - All top level class names start with Db.
  26 //  - All class members start with lower case letter.
  27 //  - All private data members are suffixed with underscore.
  28 //  - Use underscores to divide names into multiple words.
  29 //  - Simple data accessors are named with get_ or set_ prefix.
  30 //  - All method names are taken from names of functions in the C
  31 //    layer of db (usually by dropping a prefix like "db_").
  32 //    These methods have the same argument types and order,
  33 //    other than dropping the explicit arg that acts as "this".
  34 //
  35 // As a rule, each DbFoo object has exactly one underlying DB_FOO struct
  36 // (defined in db.h) associated with it.  In some cases, we inherit directly
  37 // from the DB_FOO structure to make this relationship explicit.  Often,
  38 // the underlying C layer allocates and deallocates these structures, so
  39 // there is no easy way to add any data to the DbFoo class.  When you see
  40 // a comment about whether data is permitted to be added, this is what
  41 // is going on.  Of course, if we need to add data to such C++ classes
  42 // in the future, we will arrange to have an indirect pointer to the
  43 // DB_FOO struct (as some of the classes already have).
  44 //
  45
  46 ////////////////////////////////////////////////////////////////
  47 ////////////////////////////////////////////////////////////////
  48 //
  49 // Forward declarations
  50 //
  51
  52 #include <stdarg.h>
  53
  54 #define HAVE_CXX_STDHEADERS 1
  55 #ifdef HAVE_CXX_STDHEADERS
  56 #include <iostream>
  57 #include <exception>
  58 #define __DB_STD(x)     std::x
  59 #else
  60 #include <iostream.h>
  61 #include <exception.h>
  62 #define __DB_STD(x)     x
  63 #endif
  64
  65 #include "db.h"
  66
  67 class Db;                                        // forward
  68 class Dbc;                                       // forward
  69 class DbChannel;                                 // forward
  70 class DbEnv;                                     // forward
  71 class DbHeapRecordId;                            // forward
  72 class DbInfo;                                    // forward
  73 class DbLock;                                    // forward
  74 class DbLogc;                                    // forward
  75 class DbLsn;                                     // forward
  76 class DbMpoolFile;                               // forward
  77 class DbPreplist;                                // forward
  78 class DbSequence;                                // forward
  79 class DbSite;                                    // forward
  80 class Dbt;                                       // forward
  81 class DbTxn;                                     // forward
  82
  83 class DbMultipleIterator;                        // forward
  84 class DbMultipleKeyDataIterator;                 // forward
  85 class DbMultipleRecnoDataIterator;               // forward
  86 class DbMultipleDataIterator;                    // forward
  87
  88 class DbException;                               // forward
  89 class DbDeadlockException;                       // forward
  90 class DbLockNotGrantedException;                 // forward
  91 class DbMemoryException;                         // forward
  92 class DbRepHandleDeadException;                  // forward
  93 class DbRunRecoveryException;                    // forward
  94
  95 ////////////////////////////////////////////////////////////////
  96 ////////////////////////////////////////////////////////////////
  97 //
  98 // Turn off inappropriate compiler warnings
  99 //
 100
 101 #ifdef _MSC_VER
 102
 103 // These are level 4 warnings that are explicitly disabled.
 104 // With Visual C++, by default you do not see above level 3 unless
 105 // you use /W4.  But we like to compile with the highest level
 106 // warnings to catch other errors.
 107 //
 108 // 4201: nameless struct/union
 109 //       triggered by standard include file <winnt.h>
 110 //
 111 // 4514: unreferenced inline function has been removed
 112 //       certain include files in MSVC define methods that are not called
 113 //
 114 #pragma warning(push)
 115 #pragma warning(disable: 4201 4514)
 116
 117 #endif
 118
 119 ////////////////////////////////////////////////////////////////
 120 ////////////////////////////////////////////////////////////////
 121 //
 122 // Mechanisms for declaring classes
 123 //
 124
 125 //
 126 // Every class defined in this file has an _exported next to the class name.
 127 // This is needed for WinTel machines so that the class methods can
 128 // be exported or imported in a DLL as appropriate.  Users of the DLL
 129 // use the define DB_USE_DLL.  When the DLL is built, DB_CREATE_DLL
 130 // must be defined.
 131 //
 132 #if defined(_MSC_VER)
 133
 134 #  if defined(DB_CREATE_DLL)
 135 #    define _exported __declspec(dllexport)      // creator of dll
 136 #  elif defined(DB_USE_DLL)
 137 #    define _exported __declspec(dllimport)      // user of dll
 138 #  else
 139 #    define _exported                            // static lib creator or user
 140 #  endif
 141
 142 #else /* _MSC_VER */
 143
 144 #  define _exported
 145
 146 #endif /* _MSC_VER */
 147
 148 // Some interfaces can be customized by allowing users to define
 149 // callback functions.  For performance and logistical reasons, some
 150 // callback functions must be declared in extern "C" blocks.  For others,
 151 // we allow you to declare the callbacks in C++ or C (or an extern "C"
 152 // block) as you wish.  See the set methods for the callbacks for
 153 // the choices.
 154 //
 155 extern "C" {
 156         typedef void * (*db_malloc_fcn_type)
 157                 (size_t);
 158         typedef void * (*db_realloc_fcn_type)
 159                 (void *, size_t);
 160         typedef void (*db_free_fcn_type)
 161                 (void *);
 162         typedef int (*bt_compare_fcn_type)          /*C++ version available*/
 163                 (DB *, const DBT *, const DBT *);
 164         typedef size_t (*bt_prefix_fcn_type)        /*C++ version available*/
 165                 (DB *, const DBT *, const DBT *);
 166         typedef int (*dup_compare_fcn_type)         /*C++ version available*/
 167                 (DB *, const DBT *, const DBT *);
 168         typedef int (*h_compare_fcn_type)          /*C++ version available*/
 169                 (DB *, const DBT *, const DBT *);
 170         typedef u_int32_t (*h_hash_fcn_type)        /*C++ version available*/
 171                 (DB *, const void *, u_int32_t);
 172         typedef int (*pgin_fcn_type)
 173                 (DB_ENV *dbenv, db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
 174         typedef int (*pgout_fcn_type)
 175                 (DB_ENV *dbenv, db_pgno_t pgno, void *pgaddr, DBT *pgcookie);
 176 }
 177
 178 //
 179 // Represents a database table = a set of keys with associated values.
 180 //
 181 class _exported Db
 182 {
 183         friend class DbEnv;
 184
 185 public:
 186         Db(DbEnv*, u_int32_t);      // Create a Db object.
 187         virtual ~Db();              // Calls close() if the user hasn't.
 188
 189         // These methods exactly match those in the C interface.
 190         //
 191         virtual int associate(DbTxn *txn, Db *secondary, int (*callback)
 192             (Db *, const Dbt *, const Dbt *, Dbt *), u_int32_t flags);
 193         virtual int associate_foreign(Db *foreign, int (*callback)
 194             (Db *, const Dbt *, Dbt *, const Dbt *, int *), u_int32_t flags);
 195         virtual int close(u_int32_t flags);
 196         virtual int compact(DbTxn *txnid, Dbt *start,
 197             Dbt *stop, DB_COMPACT *c_data, u_int32_t flags, Dbt *end);
 198         virtual int cursor(DbTxn *txnid, Dbc **cursorp, u_int32_t flags);
 199         virtual int del(DbTxn *txnid, Dbt *key, u_int32_t flags);
 200         virtual void err(int, const char *, ...);
 201         virtual void errx(const char *, ...);
 202         virtual int exists(DbTxn *txnid, Dbt *key, u_int32_t flags);
 203         virtual int fd(int *fdp);
 204         virtual int get(DbTxn *txnid, Dbt *key, Dbt *data, u_int32_t flags);
 205         virtual int get_alloc(
 206             db_malloc_fcn_type *, db_realloc_fcn_type *, db_free_fcn_type *);
 207         virtual int get_append_recno(int (**)(Db *, Dbt *, db_recno_t));
 208         virtual int get_bt_compare(int (**)(Db *, const Dbt *, const Dbt *));
 209         virtual int get_bt_compress(
 210             int (**)(
 211             Db *, const Dbt *, const Dbt *, const Dbt *, const Dbt *, Dbt *),
 212             int (**)(Db *, const Dbt *, const Dbt *, Dbt *, Dbt *, Dbt *));
 213         virtual int get_bt_minkey(u_int32_t *);
 214         virtual int get_bt_prefix(size_t (**)(Db *, const Dbt *, const Dbt *));
 215         virtual int get_byteswapped(int *);
 216         virtual int get_cachesize(u_int32_t *, u_int32_t *, int *);
 217         virtual int get_create_dir(const char **);
 218         virtual int get_dbname(const char **, const char **);
 219         virtual int get_dup_compare(int (**)(Db *, const Dbt *, const Dbt *));
 220         virtual int get_encrypt_flags(u_int32_t *);
 221         virtual void get_errcall(
 222             void (**)(const DbEnv *, const char *, const char *));
 223         virtual void get_errfile(FILE **);
 224         virtual void get_errpfx(const char **);
 225         virtual int get_feedback(void (**)(Db *, int, int));
 226         virtual int get_flags(u_int32_t *);
 227         virtual int get_heapsize(u_int32_t *, u_int32_t *);
 228         virtual int get_heap_regionsize(u_int32_t *);
 229         virtual int get_h_compare(int (**)(Db *, const Dbt *, const Dbt *));
 230         virtual int get_h_ffactor(u_int32_t *);
 231         virtual int get_h_hash(u_int32_t (**)(Db *, const void *, u_int32_t));
 232         virtual int get_h_nelem(u_int32_t *);
 233         virtual int get_lk_exclusive(bool *, bool *);
 234         virtual int get_lorder(int *);
 235         virtual void get_msgcall(void (**)(const DbEnv *, const char *));
 236         virtual void get_msgfile(FILE **);
 237         virtual int get_multiple();
 238         virtual int get_open_flags(u_int32_t *);
 239         virtual int get_pagesize(u_int32_t *);
 240         virtual int get_partition_callback(
 241             u_int32_t *, u_int32_t (**)(Db *, Dbt *key));
 242         virtual int get_partition_dirs(const char ***);
 243         virtual int get_partition_keys(u_int32_t *, Dbt **);
 244         virtual int get_priority(DB_CACHE_PRIORITY *);
 245         virtual int get_q_extentsize(u_int32_t *);
 246         virtual int get_re_delim(int *);
 247         virtual int get_re_len(u_int32_t *);
 248         virtual int get_re_pad(int *);
 249         virtual int get_re_source(const char **);
 250         virtual int get_transactional();
 251         virtual int get_type(DBTYPE *);
 252         virtual int join(Dbc **curslist, Dbc **dbcp, u_int32_t flags);
 253         virtual int key_range(DbTxn *, Dbt *, DB_KEY_RANGE *, u_int32_t);
 254         virtual int open(DbTxn *txnid,
 255             const char *, const char *subname, DBTYPE, u_int32_t, int);
 256         virtual int pget(DbTxn *txnid,
 257             Dbt *key, Dbt *pkey, Dbt *data, u_int32_t flags);
 258         virtual int put(DbTxn *, Dbt *, Dbt *, u_int32_t);
 259         virtual int remove(const char *, const char *, u_int32_t);
 260         virtual int rename(const char *, const char *, const char *, u_int32_t);
 261         virtual int set_alloc(
 262             db_malloc_fcn_type, db_realloc_fcn_type, db_free_fcn_type);
 263         virtual void set_app_private(void *);
 264         virtual int set_append_recno(int (*)(Db *, Dbt *, db_recno_t));
 265         virtual int set_bt_compare(bt_compare_fcn_type); /*deprecated*/
 266         virtual int set_bt_compare(int (*)(Db *, const Dbt *, const Dbt *));
 267         virtual int set_bt_compress(
 268             int (*)
 269             (Db *, const Dbt *, const Dbt *, const Dbt *, const Dbt *, Dbt *),
 270             int (*)(Db *, const Dbt *, const Dbt *, Dbt *, Dbt *, Dbt *));
 271         virtual int set_bt_minkey(u_int32_t);
 272         virtual int set_bt_prefix(bt_prefix_fcn_type); /*deprecated*/
 273         virtual int set_bt_prefix(size_t (*)(Db *, const Dbt *, const Dbt *));
 274         virtual int set_cachesize(u_int32_t, u_int32_t, int);
 275         virtual int set_create_dir(const char *);
 276         virtual int set_dup_compare(dup_compare_fcn_type); /*deprecated*/
 277         virtual int set_dup_compare(int (*)(Db *, const Dbt *, const Dbt *));
 278         virtual int set_encrypt(const char *, u_int32_t);
 279         virtual void set_errcall(
 280             void (*)(const DbEnv *, const char *, const char *));
 281         virtual void set_errfile(FILE *);
 282         virtual void set_errpfx(const char *);
 283         virtual int set_feedback(void (*)(Db *, int, int));
 284         virtual int set_flags(u_int32_t);
 285         virtual int set_heapsize(u_int32_t, u_int32_t);
 286         virtual int set_heap_regionsize(u_int32_t);
 287         virtual int set_h_compare(h_compare_fcn_type); /*deprecated*/
 288         virtual int set_h_compare(int (*)(Db *, const Dbt *, const Dbt *));
 289         virtual int set_h_ffactor(u_int32_t);
 290         virtual int set_h_hash(h_hash_fcn_type); /*deprecated*/
 291         virtual int set_h_hash(u_int32_t (*)(Db *, const void *, u_int32_t));
 292         virtual int set_h_nelem(u_int32_t);
 293         virtual int set_lk_exclusive(bool);
 294         virtual int set_lorder(int);
 295         virtual void set_msgcall(void (*)(const DbEnv *, const char *));
 296         virtual void set_msgfile(FILE *);
 297         virtual int set_pagesize(u_int32_t);
 298         virtual int set_paniccall(void (*)(DbEnv *, int));
 299         virtual int set_partition(
 300             u_int32_t, Dbt *, u_int32_t (*)(Db *, Dbt *));
 301         virtual int set_partition_dirs(const char **);
 302         virtual int set_priority(DB_CACHE_PRIORITY);
 303         virtual int set_q_extentsize(u_int32_t);
 304         virtual int set_re_delim(int);
 305         virtual int set_re_len(u_int32_t);
 306         virtual int set_re_pad(int);
 307         virtual int set_re_source(const char *);
 308         virtual int sort_multiple(Dbt *, Dbt *, u_int32_t);
 309         virtual int stat(DbTxn *, void *sp, u_int32_t flags);
 310         virtual int stat_print(u_int32_t flags);
 311         virtual int sync(u_int32_t flags);
 312         virtual int truncate(DbTxn *, u_int32_t *, u_int32_t);
 313         virtual int upgrade(const char *name, u_int32_t flags);
 314         virtual int verify(
 315             const char *, const char *, __DB_STD(ostream) *, u_int32_t);
 316
 317         // These additional methods are not in the C interface, and
 318         // are only available for C++.
 319         //
 320         virtual void *get_app_private() const;
 321         virtual __DB_STD(ostream) *get_error_stream();
 322         virtual void set_error_stream(__DB_STD(ostream) *);
 323         virtual __DB_STD(ostream) *get_message_stream();
 324         virtual void set_message_stream(__DB_STD(ostream) *);
 325
 326         virtual DbEnv *get_env();
 327         virtual DbMpoolFile *get_mpf();
 328
 329         virtual ENV *get_ENV()
 330         {
 331                 return imp_->env;
 332         }
 333
 334         virtual DB *get_DB()
 335         {
 336                 return imp_;
 337         }
 338
 339         virtual const DB *get_const_DB() const
 340         {
 341                 return imp_;
 342         }
 343
 344         static Db* get_Db(DB *db)
 345         {
 346                 return (Db *)db->api_internal;
 347         }
 348
 349         static const Db* get_const_Db(const DB *db)
 350         {
 351                 return (const Db *)db->api_internal;
 352         }
 353
 354         u_int32_t get_create_flags() const
 355         {
 356                 return construct_flags_;
 357         }
 358
 359 private:
 360         // no copying
 361         Db(const Db &);
 362         Db &operator = (const Db &);
 363
 364         void cleanup();
 365         int initialize();
 366         int error_policy();
 367
 368         // instance data
 369         DB *imp_;
 370         DbEnv *dbenv_;
 371         DbMpoolFile *mpf_;
 372         int construct_error_;
 373         u_int32_t flags_;
 374         u_int32_t construct_flags_;
 375
 376         static int alt_close(DB *, u_int32_t);
 377
 378 public:
 379         // These are public only because they need to be called
 380         // via C callback functions.  They should never be used by
 381         // external users of this class.
 382         //
 383         int (*append_recno_callback_)(Db *, Dbt *, db_recno_t);
 384         int (*associate_callback_)(Db *, const Dbt *, const Dbt *, Dbt *);
 385         int (*associate_foreign_callback_)
 386             (Db *, const Dbt *, Dbt *, const Dbt *, int *);
 387         int (*bt_compare_callback_)(Db *, const Dbt *, const Dbt *);
 388         int (*bt_compress_callback_)(
 389             Db *, const Dbt *, const Dbt *, const Dbt *, const Dbt *, Dbt *);
 390         int (*bt_decompress_callback_)(
 391             Db *, const Dbt *, const Dbt *, Dbt *, Dbt *, Dbt *);
 392         size_t (*bt_prefix_callback_)(Db *, const Dbt *, const Dbt *);
 393         u_int32_t (*db_partition_callback_)(Db *, Dbt *);
 394         int (*dup_compare_callback_)(Db *, const Dbt *, const Dbt *);
 395         void (*feedback_callback_)(Db *, int, int);
 396         int (*h_compare_callback_)(Db *, const Dbt *, const Dbt *);
 397         u_int32_t (*h_hash_callback_)(Db *, const void *, u_int32_t);
 398 };
 399
 400 //
 401 // Cursor
 402 //
 403 class _exported Dbc : protected DBC
 404 {
 405         friend class Db;
 406
 407 public:
 408         int close();
 409         int cmp(Dbc *other_csr, int *result, u_int32_t flags);
 410         int count(db_recno_t *countp, u_int32_t flags);
 411         int del(u_int32_t flags);
 412         int dup(Dbc** cursorp, u_int32_t flags);
 413         int get(Dbt* key, Dbt *data, u_int32_t flags);
 414         int get_priority(DB_CACHE_PRIORITY *priorityp);
 415         int pget(Dbt* key, Dbt* pkey, Dbt *data, u_int32_t flags);
 416         int put(Dbt* key, Dbt *data, u_int32_t flags);
 417         int set_priority(DB_CACHE_PRIORITY priority);
 418
 419 private:
 420         // No data is permitted in this class (see comment at top)
 421
 422         // Note: use Db::cursor() to get pointers to a Dbc,
 423         // and call Dbc::close() rather than delete to release them.
 424         //
 425         Dbc();
 426         ~Dbc();
 427
 428         // no copying
 429         Dbc(const Dbc &);
 430         Dbc &operator = (const Dbc &);
 431 };
 432
 433 //
 434 // A channel in replication group
 435 //
 436 class _exported DbChannel
 437 {
 438         friend class DbEnv;
 439
 440 public:
 441         int close();
 442         int send_msg(Dbt *msg, u_int32_t nmsg, u_int32_t flags);
 443         int send_request(Dbt *request, u_int32_t nrequest, Dbt *response,
 444             db_timeout_t timeout, u_int32_t flags);
 445         int set_timeout(db_timeout_t timeout);
 446
 447         virtual DB_CHANNEL *get_DB_CHANNEL()
 448         {
 449                 return imp_;
 450         }
 451
 452         virtual const DB_CHANNEL *get_const_DB_CHANNEL() const
 453         {
 454                 return imp_;
 455         }
 456
 457 private:
 458         DbChannel();
 459         virtual ~DbChannel();
 460
 461         // no copying
 462         DbChannel(const DbChannel &);
 463         DbChannel &operator = (const DbChannel &);
 464         DB_CHANNEL *imp_;
 465         DbEnv *dbenv_;
 466 };
 467
 468 //
 469 // Berkeley DB environment class.  Provides functions for opening databases.
 470 // User of this library can use this class as a starting point for
 471 // developing a DB application - derive their application class from
 472 // this one, add application control logic.
 473 //
 474 // Note that if you use the default constructor, you must explicitly
 475 // call appinit() before any other db activity (e.g. opening files)
 476 //
 477 class _exported DbEnv
 478 {
 479         friend class Db;
 480         friend class DbLock;
 481         friend class DbMpoolFile;
 482
 483 public:
 484         // After using this constructor, you can set any needed
 485         // parameters for the environment using the set_* methods.
 486         // Then call open() to finish initializing the environment
 487         // and attaching it to underlying files.
 488         //
 489         DbEnv(u_int32_t flags);
 490
 491         virtual ~DbEnv();
 492
 493         // These methods match those in the C interface.
 494         //
 495         virtual int add_data_dir(const char *);
 496         virtual int backup(const char *target, u_int32_t flags);
 497         virtual int cdsgroup_begin(DbTxn **tid);
 498         virtual int close(u_int32_t);
 499         virtual int dbbackup(
 500             const char *dbfile, const char *target, u_int32_t flags);
 501         virtual int dbremove(DbTxn *txn, const char *name, const char *subdb,
 502             u_int32_t flags);
 503         virtual int dbrename(DbTxn *txn, const char *name, const char *subdb,
 504             const char *newname, u_int32_t flags);
 505         virtual void err(int, const char *, ...);
 506         virtual void errx(const char *, ...);
 507         virtual int failchk(u_int32_t);
 508         virtual int fileid_reset(const char *, u_int32_t);
 509         virtual int get_alloc(db_malloc_fcn_type *, db_realloc_fcn_type *,
 510             db_free_fcn_type *);
 511         virtual void *get_app_private() const;
 512         virtual int get_home(const char **);
 513         virtual int get_open_flags(u_int32_t *);
 514         virtual int open(const char *, u_int32_t, int);
 515         virtual int remove(const char *, u_int32_t);
 516         virtual int stat_print(u_int32_t flags);
 517
 518         virtual int set_alloc(db_malloc_fcn_type, db_realloc_fcn_type,
 519             db_free_fcn_type);
 520         virtual void set_app_private(void *);
 521         virtual int get_backup_callbacks(
 522             int (**)(DbEnv *, const char *, const char *, void **),
 523             int (**)(DbEnv *, u_int32_t, u_int32_t, u_int32_t, u_int8_t *, void *),
 524             int (**)(DbEnv *, const char *, void *));
 525         virtual int set_backup_callbacks(
 526             int (*)(DbEnv *, const char *, const char *, void **),
 527             int (*)(DbEnv *, u_int32_t, u_int32_t, u_int32_t, u_int8_t *, void *),
 528             int (*)(DbEnv *, const char *, void *));
 529         virtual int get_backup_config(DB_BACKUP_CONFIG, u_int32_t *);
 530         virtual int set_backup_config(DB_BACKUP_CONFIG, u_int32_t);
 531         virtual int get_cachesize(u_int32_t *, u_int32_t *, int *);
 532         virtual int set_cachesize(u_int32_t, u_int32_t, int);
 533         virtual int get_cache_max(u_int32_t *, u_int32_t *);
 534         virtual int set_cache_max(u_int32_t, u_int32_t);
 535         virtual int get_create_dir(const char **);
 536         virtual int set_create_dir(const char *);
 537         virtual int get_data_dirs(const char ***);
 538         virtual int set_data_dir(const char *);
 539         virtual int get_encrypt_flags(u_int32_t *);
 540         virtual int get_intermediate_dir_mode(const char **);
 541         virtual int set_intermediate_dir_mode(const char *);
 542         virtual int get_isalive(
 543             int (**)(DbEnv *, pid_t, db_threadid_t, u_int32_t));
 544         virtual int set_isalive(
 545             int (*)(DbEnv *, pid_t, db_threadid_t, u_int32_t));
 546         virtual int set_encrypt(const char *, u_int32_t);
 547         virtual void get_errcall(
 548             void (**)(const DbEnv *, const char *, const char *));
 549         virtual void set_errcall(
 550             void (*)(const DbEnv *, const char *, const char *));
 551         virtual void get_errfile(FILE **);
 552         virtual void set_errfile(FILE *);
 553         virtual void get_errpfx(const char **);
 554         virtual void set_errpfx(const char *);
 555         virtual int set_event_notify(void (*)(DbEnv *, u_int32_t, void *));
 556         virtual int get_flags(u_int32_t *);
 557         virtual int set_flags(u_int32_t, int);
 558         virtual bool is_bigendian();
 559         virtual int lsn_reset(const char *, u_int32_t);
 560         virtual int get_feedback(void (**)(DbEnv *, int, int));
 561         virtual int set_feedback(void (*)(DbEnv *, int, int));
 562         virtual int get_lg_bsize(u_int32_t *);
 563         virtual int set_lg_bsize(u_int32_t);
 564         virtual int get_lg_dir(const char **);
 565         virtual int set_lg_dir(const char *);
 566         virtual int get_lg_filemode(int *);
 567         virtual int set_lg_filemode(int);
 568         virtual int get_lg_max(u_int32_t *);
 569         virtual int set_lg_max(u_int32_t);
 570         virtual int get_lg_regionmax(u_int32_t *);
 571         virtual int set_lg_regionmax(u_int32_t);
 572         virtual int get_lk_conflicts(const u_int8_t **, int *);
 573         virtual int set_lk_conflicts(u_int8_t *, int);
 574         virtual int get_lk_detect(u_int32_t *);
 575         virtual int set_lk_detect(u_int32_t);
 576         virtual int get_lk_max_lockers(u_int32_t *);
 577         virtual int set_lk_max_lockers(u_int32_t);
 578         virtual int get_lk_max_locks(u_int32_t *);
 579         virtual int set_lk_max_locks(u_int32_t);
 580         virtual int get_lk_max_objects(u_int32_t *);
 581         virtual int set_lk_max_objects(u_int32_t);
 582         virtual int get_lk_partitions(u_int32_t *);
 583         virtual int set_lk_partitions(u_int32_t);
 584         virtual int get_lk_priority(u_int32_t, u_int32_t *);
 585         virtual int set_lk_priority(u_int32_t, u_int32_t);
 586         virtual int get_lk_tablesize(u_int32_t *);
 587         virtual int set_lk_tablesize(u_int32_t);
 588         virtual int get_memory_init(DB_MEM_CONFIG, u_int32_t *);
 589         virtual int set_memory_init(DB_MEM_CONFIG, u_int32_t);
 590         virtual int get_memory_max(u_int32_t *, u_int32_t *);
 591         virtual int set_memory_max(u_int32_t, u_int32_t);
 592         virtual int get_metadata_dir(const char **);
 593         virtual int set_metadata_dir(const char *);
 594         virtual int get_mp_mmapsize(size_t *);
 595         virtual int set_mp_mmapsize(size_t);
 596         virtual int get_mp_max_openfd(int *);
 597         virtual int set_mp_max_openfd(int);
 598         virtual int get_mp_max_write(int *, db_timeout_t *);
 599         virtual int set_mp_max_write(int, db_timeout_t);
 600         virtual int get_mp_pagesize(u_int32_t *);
 601         virtual int set_mp_pagesize(u_int32_t);
 602         virtual int get_mp_tablesize(u_int32_t *);
 603         virtual int set_mp_tablesize(u_int32_t);
 604         virtual void get_msgcall(void (**)(const DbEnv *, const char *));
 605         virtual void set_msgcall(void (*)(const DbEnv *, const char *));
 606         virtual void get_msgfile(FILE **);
 607         virtual void set_msgfile(FILE *);
 608         virtual int set_paniccall(void (*)(DbEnv *, int));
 609         virtual int get_shm_key(long *);
 610         virtual int set_shm_key(long);
 611         virtual int get_timeout(db_timeout_t *, u_int32_t);
 612         virtual int set_timeout(db_timeout_t, u_int32_t);
 613         virtual int get_tmp_dir(const char **);
 614         virtual int set_tmp_dir(const char *);
 615         virtual int get_tx_max(u_int32_t *);
 616         virtual int set_tx_max(u_int32_t);
 617         virtual int get_app_dispatch(
 618             int (**)(DbEnv *, Dbt *, DbLsn *, db_recops));
 619         virtual int set_app_dispatch(int (*)(DbEnv *,
 620             Dbt *, DbLsn *, db_recops));
 621         virtual int get_tx_timestamp(time_t *);
 622         virtual int set_tx_timestamp(time_t *);
 623         virtual int get_verbose(u_int32_t which, int *);
 624         virtual int set_verbose(u_int32_t which, int);
 625
 626         // Version information.  Static methods, can be called at any time.
 627         //
 628         static char *version(int *major, int *minor, int *patch);
 629         static char *full_version(int *family, int *release,
 630             int *major, int *minor, int *patch);
 631
 632         // Convert DB errors to strings
 633         static char *strerror(int);
 634
 635         // If an error is detected and the error call function
 636         // or stream is set, a message is dispatched or printed.
 637         // If a prefix is set, each message is prefixed.
 638         //
 639         // You can use set_errcall() or set_errfile() above to control
 640         // error functionality.  Alternatively, you can call
 641         // set_error_stream() to force all errors to a C++ stream.
 642         // It is unwise to mix these approaches.
 643         //
 644         virtual __DB_STD(ostream) *get_error_stream();
 645         virtual void set_error_stream(__DB_STD(ostream) *);
 646         virtual __DB_STD(ostream) *get_message_stream();
 647         virtual void set_message_stream(__DB_STD(ostream) *);
 648
 649         // used internally
 650         static void runtime_error(DbEnv *dbenv, const char *caller, int err,
 651                                   int error_policy);
 652         static void runtime_error_dbt(DbEnv *dbenv, const char *caller, Dbt *dbt,
 653                                   int error_policy);
 654         static void runtime_error_lock_get(DbEnv *dbenv, const char *caller,
 655                                   int err, db_lockop_t op, db_lockmode_t mode,
 656                                   Dbt *obj, DbLock lock, int index,
 657                                   int error_policy);
 658
 659         // Lock functions
 660         //
 661         virtual int lock_detect(u_int32_t flags, u_int32_t atype, int *aborted);
 662         virtual int lock_get(u_int32_t locker, u_int32_t flags, Dbt *obj,
 663                      db_lockmode_t lock_mode, DbLock *lock);
 664         virtual int lock_id(u_int32_t *idp);
 665         virtual int lock_id_free(u_int32_t id);
 666         virtual int lock_put(DbLock *lock);
 667         virtual int lock_stat(DB_LOCK_STAT **statp, u_int32_t flags);
 668         virtual int lock_stat_print(u_int32_t flags);
 669         virtual int lock_vec(u_int32_t locker, u_int32_t flags,
 670                      DB_LOCKREQ list[], int nlist, DB_LOCKREQ **elistp);
 671
 672         // Log functions
 673         //
 674         virtual int log_archive(char **list[], u_int32_t flags);
 675         static int log_compare(const DbLsn *lsn0, const DbLsn *lsn1);
 676         virtual int log_cursor(DbLogc **cursorp, u_int32_t flags);
 677         virtual int log_file(DbLsn *lsn, char *namep, size_t len);
 678         virtual int log_flush(const DbLsn *lsn);
 679         virtual int log_get_config(u_int32_t, int *);
 680         virtual int log_put(DbLsn *lsn, const Dbt *data, u_int32_t flags);
 681         virtual int log_printf(DbTxn *, const char *, ...);
 682         virtual int log_set_config(u_int32_t, int);
 683         virtual int log_stat(DB_LOG_STAT **spp, u_int32_t flags);
 684         virtual int log_stat_print(u_int32_t flags);
 685         virtual int log_verify(DB_LOG_VERIFY_CONFIG *);
 686
 687         // Mpool functions
 688         //
 689         virtual int memp_fcreate(DbMpoolFile **dbmfp, u_int32_t flags);
 690         virtual int memp_register(int ftype,
 691                           pgin_fcn_type pgin_fcn,
 692                           pgout_fcn_type pgout_fcn);
 693         virtual int memp_stat(DB_MPOOL_STAT
 694                       **gsp, DB_MPOOL_FSTAT ***fsp, u_int32_t flags);
 695         virtual int memp_stat_print(u_int32_t flags);
 696         virtual int memp_sync(DbLsn *lsn);
 697         virtual int memp_trickle(int pct, int *nwrotep);
 698
 699         // Mpool functions
 700         //
 701         virtual int mutex_alloc(u_int32_t, db_mutex_t *);
 702         virtual int mutex_free(db_mutex_t);
 703         virtual int mutex_get_align(u_int32_t *);
 704         virtual int mutex_get_increment(u_int32_t *);
 705         virtual int mutex_get_init(u_int32_t *);
 706         virtual int mutex_get_max(u_int32_t *);
 707         virtual int mutex_get_tas_spins(u_int32_t *);
 708         virtual int mutex_lock(db_mutex_t);
 709         virtual int mutex_set_align(u_int32_t);
 710         virtual int mutex_set_increment(u_int32_t);
 711         virtual int mutex_set_init(u_int32_t);
 712         virtual int mutex_set_max(u_int32_t);
 713         virtual int mutex_set_tas_spins(u_int32_t);
 714         virtual int mutex_stat(DB_MUTEX_STAT **, u_int32_t);
 715         virtual int mutex_stat_print(u_int32_t);
 716         virtual int mutex_unlock(db_mutex_t);
 717
 718         // Transaction functions
 719         //
 720         virtual int txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags);
 721         virtual int txn_checkpoint(u_int32_t kbyte, u_int32_t min,
 722                         u_int32_t flags);
 723         virtual int txn_recover(DbPreplist *preplist, long count,
 724                         long *retp, u_int32_t flags);
 725         virtual int txn_stat(DB_TXN_STAT **statp, u_int32_t flags);
 726         virtual int txn_stat_print(u_int32_t flags);
 727
 728         // Replication functions
 729         //
 730         virtual int rep_elect(u_int32_t, u_int32_t, u_int32_t);
 731         virtual int rep_flush();
 732         virtual int rep_process_message(Dbt *, Dbt *, int, DbLsn *);
 733         virtual int rep_start(Dbt *, u_int32_t);
 734         virtual int rep_stat(DB_REP_STAT **statp, u_int32_t flags);
 735         virtual int rep_stat_print(u_int32_t flags);
 736         virtual int rep_get_clockskew(u_int32_t *, u_int32_t *);
 737         virtual int rep_set_clockskew(u_int32_t, u_int32_t);
 738         virtual int rep_get_limit(u_int32_t *, u_int32_t *);
 739         virtual int rep_set_limit(u_int32_t, u_int32_t);
 740         virtual int rep_set_transport(int, int (*)(DbEnv *,
 741             const Dbt *, const Dbt *, const DbLsn *, int, u_int32_t));
 742         virtual int rep_set_request(u_int32_t, u_int32_t);
 743         virtual int rep_get_request(u_int32_t *, u_int32_t *);
 744         virtual int get_thread_count(u_int32_t *);
 745         virtual int set_thread_count(u_int32_t);
 746         virtual int get_thread_id_fn(
 747             void (**)(DbEnv *, pid_t *, db_threadid_t *));
 748         virtual int set_thread_id(void (*)(DbEnv *, pid_t *, db_threadid_t *));
 749         virtual int get_thread_id_string_fn(
 750             char *(**)(DbEnv *, pid_t, db_threadid_t, char *));
 751         virtual int set_thread_id_string(char *(*)(DbEnv *,
 752             pid_t, db_threadid_t, char *));
 753         virtual int rep_set_config(u_int32_t, int);
 754         virtual int rep_get_config(u_int32_t, int *);
 755         virtual int rep_sync(u_int32_t flags);
 756
 757         // Advanced replication functions
 758         //
 759         virtual int rep_get_nsites(u_int32_t *n);
 760         virtual int rep_set_nsites(u_int32_t n);
 761         virtual int rep_get_priority(u_int32_t *priorityp);
 762         virtual int rep_set_priority(u_int32_t priority);
 763         virtual int rep_get_timeout(int which, db_timeout_t *timeout);
 764         virtual int rep_set_timeout(int which, db_timeout_t timeout);
 765         virtual int repmgr_channel(int eid, DbChannel **channel,
 766             u_int32_t flags);
 767         virtual int repmgr_get_ack_policy(int *policy);
 768         virtual int repmgr_set_ack_policy(int policy);
 769         virtual int repmgr_local_site(DbSite **site);
 770         virtual int repmgr_msg_dispatch(void (*) (DbEnv *,
 771             DbChannel *, Dbt *, u_int32_t, u_int32_t), u_int32_t flags);
 772         virtual int repmgr_site(const char *host, u_int port, DbSite **site,
 773             u_int32_t flags);
 774         virtual int repmgr_site_by_eid(int eid, DbSite **site);
 775         virtual int repmgr_site_list(u_int *countp, DB_REPMGR_SITE **listp);
 776         virtual int repmgr_start(int nthreads, u_int32_t flags);
 777         virtual int repmgr_stat(DB_REPMGR_STAT **statp, u_int32_t flags);
 778         virtual int repmgr_stat_print(u_int32_t flags);
 779
 780         // Conversion functions
 781         //
 782         virtual ENV *get_ENV()
 783         {
 784                 return imp_->env;
 785         }
 786
 787         virtual DB_ENV *get_DB_ENV()
 788         {
 789                 return imp_;
 790         }
 791
 792         virtual const DB_ENV *get_const_DB_ENV() const
 793         {
 794                 return imp_;
 795         }
 796
 797         static DbEnv* get_DbEnv(DB_ENV *dbenv)
 798         {
 799                 return dbenv ? (DbEnv *)dbenv->api1_internal : 0;
 800         }
 801
 802         static const DbEnv* get_const_DbEnv(const DB_ENV *dbenv)
 803         {
 804                 return dbenv ? (const DbEnv *)dbenv->api1_internal : 0;
 805         }
 806
 807         u_int32_t get_create_flags() const
 808         {
 809                 return construct_flags_;
 810         }
 811
 812         // For internal use only.
 813         static DbEnv* wrap_DB_ENV(DB_ENV *dbenv);
 814
 815         // These are public only because they need to be called
 816         // via C functions.  They should never be called by users
 817         // of this class.
 818         //
 819         static int _app_dispatch_intercept(DB_ENV *dbenv, DBT *dbt, DB_LSN *lsn,
 820                                        db_recops op);
 821         static int _backup_close_intercept(DB_ENV *dbenv,
 822             const char *dbname, void *handle);
 823         static int _backup_open_intercept(DB_ENV *dbenv,
 824             const char *dbname, const char *target, void **handle);
 825         static int _backup_write_intercept(DB_ENV *dbenv, u_int32_t off_gbytes,
 826             u_int32_t off_bytes, u_int32_t size, u_int8_t *buf, void *handle);
 827         static void _paniccall_intercept(DB_ENV *dbenv, int errval);
 828         static void _feedback_intercept(DB_ENV *dbenv, int opcode, int pct);
 829         static void  _event_func_intercept(DB_ENV *dbenv, u_int32_t, void *);
 830         static int _isalive_intercept(DB_ENV *dbenv, pid_t pid,
 831             db_threadid_t thrid, u_int32_t flags);
 832         static int _rep_send_intercept(DB_ENV *dbenv, const DBT *cntrl,
 833             const DBT *data, const DB_LSN *lsn, int id, u_int32_t flags);
 834         static void _stream_error_function(const DB_ENV *dbenv,
 835             const char *prefix, const char *message);
 836         static void _stream_message_function(const DB_ENV *dbenv,
 837             const char *message);
 838         static void _thread_id_intercept(DB_ENV *dbenv, pid_t *pidp,
 839             db_threadid_t *thridp);
 840         static char *_thread_id_string_intercept(DB_ENV *dbenv, pid_t pid,
 841             db_threadid_t thrid, char *buf);
 842         static void _message_dispatch_intercept(DB_ENV *dbenv,
 843             DB_CHANNEL *dbchannel, DBT *request, u_int32_t nrequest,
 844             u_int32_t cb_flags);
 845
 846 private:
 847         void cleanup();
 848         int initialize(DB_ENV *dbenv);
 849         int error_policy();
 850
 851         // For internal use only.
 852         DbEnv(DB_ENV *, u_int32_t flags);
 853
 854         // no copying
 855         DbEnv(const DbEnv &);
 856         void operator = (const DbEnv &);
 857
 858         // instance data
 859         DB_ENV *imp_;
 860         int construct_error_;
 861         u_int32_t construct_flags_;
 862         __DB_STD(ostream) *error_stream_;
 863         __DB_STD(ostream) *message_stream_;
 864
 865         int (*app_dispatch_callback_)(DbEnv *, Dbt *, DbLsn *, db_recops);
 866         int (*backup_close_callback_)(DbEnv *, const char *, void *);
 867         int (*backup_open_callback_)(
 868             DbEnv *, const char *, const char *, void **);
 869         int (*backup_write_callback_)(
 870             DbEnv *, u_int32_t, u_int32_t, u_int32_t, u_int8_t *, void *);
 871         int (*isalive_callback_)(DbEnv *, pid_t, db_threadid_t, u_int32_t);
 872         void (*error_callback_)(const DbEnv *, const char *, const char *);
 873         void (*feedback_callback_)(DbEnv *, int, int);
 874         void (*message_callback_)(const DbEnv *, const char *);
 875         void (*paniccall_callback_)(DbEnv *, int);
 876         void (*event_func_callback_)(DbEnv *, u_int32_t, void *);
 877         int (*rep_send_callback_)(DbEnv *, const Dbt *, const Dbt *,
 878             const DbLsn *, int, u_int32_t);
 879         void (*thread_id_callback_)(DbEnv *, pid_t *, db_threadid_t *);
 880         char *(*thread_id_string_callback_)(DbEnv *, pid_t, db_threadid_t,
 881             char *);
 882         void (*message_dispatch_callback_)(DbEnv *, DbChannel *, Dbt *,
 883             u_int32_t, u_int32_t);
 884 };
 885
 886 //
 887 // Heap record id
 888 //
 889 class _exported DbHeapRecordId : private DB_HEAP_RID
 890 {
 891 public:
 892         db_pgno_t get_pgno() const              { return pgno; }
 893         void set_pgno(db_pgno_t value)          { pgno = value; }
 894
 895         db_indx_t get_indx() const              { return indx; }
 896         void set_indx(db_indx_t value)          { indx = value; }
 897
 898         DB_HEAP_RID *get_DB_HEAP_RID()          { return (DB_HEAP_RID *)this; }
 899         const DB_HEAP_RID *get_const_DB_HEAP_RID() const
 900                                         { return (const DB_HEAP_RID *)this; }
 901
 902         static DbHeapRecordId* get_DbHeapRecordId(DB_HEAP_RID *rid)
 903                                         { return (DbHeapRecordId *)rid; }
 904         static const DbHeapRecordId* get_const_DbHeapRecordId(DB_HEAP_RID *rid)
 905                                         { return (const DbHeapRecordId *)rid; }
 906
 907         DbHeapRecordId(db_pgno_t pgno, db_indx_t indx);
 908         DbHeapRecordId();
 909         ~DbHeapRecordId();
 910         DbHeapRecordId(const DbHeapRecordId &);
 911         DbHeapRecordId &operator = (const DbHeapRecordId &);
 912 };
 913
 914 //
 915 // Lock
 916 //
 917 class _exported DbLock
 918 {
 919         friend class DbEnv;
 920
 921 public:
 922         DbLock();
 923         DbLock(const DbLock &);
 924         DbLock &operator = (const DbLock &);
 925
 926 protected:
 927         // We can add data to this class if needed
 928         // since its contained class is not allocated by db.
 929         // (see comment at top)
 930
 931         DbLock(DB_LOCK);
 932         DB_LOCK lock_;
 933 };
 934
 935 //
 936 // Log cursor
 937 //
 938 class _exported DbLogc : protected DB_LOGC
 939 {
 940         friend class DbEnv;
 941
 942 public:
 943         int close(u_int32_t _flags);
 944         int get(DbLsn *lsn, Dbt *data, u_int32_t _flags);
 945         int version(u_int32_t *versionp, u_int32_t _flags);
 946
 947 private:
 948         // No data is permitted in this class (see comment at top)
 949
 950         // Note: use Db::cursor() to get pointers to a Dbc,
 951         // and call Dbc::close() rather than delete to release them.
 952         //
 953         DbLogc();
 954         ~DbLogc();
 955
 956         // no copying
 957         DbLogc(const Dbc &);
 958         DbLogc &operator = (const Dbc &);
 959 };
 960
 961 //
 962 // Log sequence number
 963 //
 964 class _exported DbLsn : public DB_LSN
 965 {
 966         friend class DbEnv;          // friendship needed to cast to base class
 967         friend class DbLogc;         // friendship needed to cast to base class
 968 };
 969
 970 //
 971 // Memory pool file
 972 //
 973 class _exported DbMpoolFile
 974 {
 975         friend class DbEnv;
 976         friend class Db;
 977
 978 public:
 979         int close(u_int32_t flags);
 980         int get(db_pgno_t *pgnoaddr, DbTxn *txn, u_int32_t flags, void *pagep);
 981         int get_clear_len(u_int32_t *len);
 982         int get_fileid(u_int8_t *fileid);
 983         int get_flags(u_int32_t *flagsp);
 984         int get_ftype(int *ftype);
 985         int get_last_pgno(db_pgno_t *pgnop);
 986         int get_lsn_offset(int32_t *offsetp);
 987         int get_maxsize(u_int32_t *gbytes, u_int32_t *bytes);
 988         int get_pgcookie(DBT *dbt);
 989         int get_priority(DB_CACHE_PRIORITY *priorityp);
 990         int get_transactional(void);
 991         int open(const char *file, u_int32_t flags, int mode, size_t pagesize);
 992         int put(void *pgaddr, DB_CACHE_PRIORITY priority, u_int32_t flags);
 993         int set_clear_len(u_int32_t len);
 994         int set_fileid(u_int8_t *fileid);
 995         int set_flags(u_int32_t flags, int onoff);
 996         int set_ftype(int ftype);
 997         int set_lsn_offset(int32_t offset);
 998         int set_maxsize(u_int32_t gbytes, u_int32_t bytes);
 999         int set_pgcookie(DBT *dbt);
1000         int set_priority(DB_CACHE_PRIORITY priority);
1001         int sync();
1002
1003         virtual DB_MPOOLFILE *get_DB_MPOOLFILE()
1004         {
1005                 return imp_;
1006         }
1007
1008         virtual const DB_MPOOLFILE *get_const_DB_MPOOLFILE() const
1009         {
1010                 return imp_;
1011         }
1012
1013 private:
1014         DB_MPOOLFILE *imp_;
1015
1016         // We can add data to this class if needed
1017         // since it is implemented via a pointer.
1018         // (see comment at top)
1019
1020         // Note: use DbEnv::memp_fcreate() to get pointers to a DbMpoolFile,
1021         // and call DbMpoolFile::close() rather than delete to release them.
1022         //
1023         DbMpoolFile();
1024
1025         // Shut g++ up.
1026 protected:
1027         virtual ~DbMpoolFile();
1028
1029 private:
1030         // no copying
1031         DbMpoolFile(const DbMpoolFile &);
1032         void operator = (const DbMpoolFile &);
1033 };
1034
1035 //
1036 // This is filled in and returned by the DbEnv::txn_recover() method.
1037 //
1038 class _exported DbPreplist
1039 {
1040 public:
1041         DbTxn *txn;
1042         u_int8_t gid[DB_GID_SIZE];
1043 };
1044
1045 //
1046 // A sequence record in a database
1047 //
1048 class _exported DbSequence
1049 {
1050 public:
1051         DbSequence(Db *db, u_int32_t flags);
1052         virtual ~DbSequence();
1053
1054         int open(DbTxn *txnid, Dbt *key, u_int32_t flags);
1055         int initial_value(db_seq_t value);
1056         int close(u_int32_t flags);
1057         int remove(DbTxn *txnid, u_int32_t flags);
1058         int stat(DB_SEQUENCE_STAT **sp, u_int32_t flags);
1059         int stat_print(u_int32_t flags);
1060
1061         int get(DbTxn *txnid, int32_t delta, db_seq_t *retp, u_int32_t flags);
1062         int get_cachesize(int32_t *sizep);
1063         int set_cachesize(int32_t size);
1064         int get_flags(u_int32_t *flagsp);
1065         int set_flags(u_int32_t flags);
1066         int get_range(db_seq_t *minp, db_seq_t *maxp);
1067         int set_range(db_seq_t min, db_seq_t max);
1068
1069         Db *get_db();
1070         Dbt *get_key();
1071
1072         virtual DB_SEQUENCE *get_DB_SEQUENCE()
1073         {
1074                 return imp_;
1075         }
1076
1077         virtual const DB_SEQUENCE *get_const_DB_SEQUENCE() const
1078         {
1079                 return imp_;
1080         }
1081
1082         static DbSequence* get_DbSequence(DB_SEQUENCE *seq)
1083         {
1084                 return (DbSequence *)seq->api_internal;
1085         }
1086
1087         static const DbSequence* get_const_DbSequence(const DB_SEQUENCE *seq)
1088         {
1089                 return (const DbSequence *)seq->api_internal;
1090         }
1091
1092         // For internal use only.
1093         static DbSequence* wrap_DB_SEQUENCE(DB_SEQUENCE *seq);
1094
1095 private:
1096         DbSequence(DB_SEQUENCE *seq);
1097         // no copying
1098         DbSequence(const DbSequence &);
1099         DbSequence &operator = (const DbSequence &);
1100
1101         DB_SEQUENCE *imp_;
1102         DBT key_;
1103 };
1104
1105 //
1106 // A site in replication group
1107 //
1108 class _exported DbSite
1109 {
1110         friend class DbEnv;
1111
1112 public:
1113         int close();
1114         int get_address(const char **hostp, u_int *port);
1115         int get_config(u_int32_t which, u_int32_t *value);
1116         int get_eid(int *eidp);
1117         int remove();
1118         int set_config(u_int32_t which, u_int32_t value);
1119
1120         virtual DB_SITE *get_DB_SITE()
1121         {
1122                 return imp_;
1123         }
1124
1125         virtual const DB_SITE *get_const_DB_SITE() const
1126         {
1127                 return imp_;
1128         }
1129
1130 private:
1131         DbSite();
1132         virtual ~DbSite();
1133
1134         // no copying
1135         DbSite(const DbSite &);
1136         DbSite &operator = (const DbSite &);
1137         DB_SITE *imp_;
1138 };
1139
1140 //
1141 // Transaction
1142 //
1143 class _exported DbTxn
1144 {
1145         friend class DbEnv;
1146
1147 public:
1148         int abort();
1149         int commit(u_int32_t flags);
1150         int discard(u_int32_t flags);
1151         u_int32_t id();
1152         int get_name(const char **namep);
1153         int get_priority(u_int32_t *priorityp);
1154         int prepare(u_int8_t *gid);
1155         int set_name(const char *name);
1156         int set_priority(u_int32_t priority);
1157         int set_timeout(db_timeout_t timeout, u_int32_t flags);
1158
1159         virtual DB_TXN *get_DB_TXN()
1160         {
1161                 return imp_;
1162         }
1163
1164         virtual const DB_TXN *get_const_DB_TXN() const
1165         {
1166                 return imp_;
1167         }
1168
1169         static DbTxn* get_DbTxn(DB_TXN *txn)
1170         {
1171                 return (DbTxn *)txn->api_internal;
1172         }
1173
1174         static const DbTxn* get_const_DbTxn(const DB_TXN *txn)
1175         {
1176                 return (const DbTxn *)txn->api_internal;
1177         }
1178
1179         // For internal use only.
1180         static DbTxn* wrap_DB_TXN(DB_TXN *txn);
1181         void remove_child_txn(DbTxn *kid);
1182         void add_child_txn(DbTxn *kid);
1183
1184         void set_parent(DbTxn *ptxn)
1185         {
1186                 parent_txn_ = ptxn;
1187         }
1188
1189 private:
1190         DB_TXN *imp_;
1191
1192         // We use a TAILQ to store this object's kids of DbTxn objects, and
1193         // each kid has a "parent_txn_" to point to this DbTxn object.
1194         //
1195         // If imp_ has a parent transaction which is not wrapped by DbTxn
1196         // class, parent_txn_ will be NULL since we don't need to maintain
1197         // this parent-kid relationship. This relationship only helps to
1198         // delete unresolved kids when the parent is resolved.
1199         DbTxn *parent_txn_;
1200
1201         // We can add data to this class if needed
1202         // since it is implemented via a pointer.
1203         // (see comment at top)
1204
1205         // Note: use DbEnv::txn_begin() to get pointers to a DbTxn,
1206         // and call DbTxn::abort() or DbTxn::commit rather than
1207         // delete to release them.
1208         //
1209         DbTxn(DbTxn *ptxn);
1210         // For internal use only.
1211         DbTxn(DB_TXN *txn, DbTxn *ptxn);
1212         virtual ~DbTxn();
1213
1214         // no copying
1215         DbTxn(const DbTxn &);
1216         void operator = (const DbTxn &);
1217
1218         /*
1219          * !!!
1220          * Explicit representations of structures from queue.h.
1221          * TAILQ_HEAD(__children, DbTxn) children;
1222          */
1223         struct __children {
1224                 DbTxn *tqh_first;
1225                 DbTxn **tqh_last;
1226         } children;
1227
1228         /*
1229          * !!!
1230          * Explicit representations of structures from queue.h.
1231          * TAILQ_ENTRY(DbTxn) child_entry;
1232          */
1233         struct {
1234                 DbTxn *tqe_next;
1235                 DbTxn **tqe_prev;
1236         } child_entry;
1237 };
1238
1239 //
1240 // A chunk of data, maybe a key or value.
1241 //
1242 class _exported Dbt : private DBT
1243 {
1244         friend class Db;
1245         friend class Dbc;
1246         friend class DbEnv;
1247         friend class DbLogc;
1248         friend class DbSequence;
1249
1250 public:
1251         // key/data
1252         void *get_data() const                 { return data; }
1253         void set_data(void *value)             { data = value; }
1254
1255         // key/data length
1256         u_int32_t get_size() const             { return size; }
1257         void set_size(u_int32_t value)         { size = value; }
1258
1259         // RO: length of user buffer.
1260         u_int32_t get_ulen() const             { return ulen; }
1261         void set_ulen(u_int32_t value)         { ulen = value; }
1262
1263         // RO: get/put record length.
1264         u_int32_t get_dlen() const             { return dlen; }
1265         void set_dlen(u_int32_t value)         { dlen = value; }
1266
1267         // RO: get/put record offset.
1268         u_int32_t get_doff() const             { return doff; }
1269         void set_doff(u_int32_t value)         { doff = value; }
1270
1271         // flags
1272         u_int32_t get_flags() const            { return flags; }
1273         void set_flags(u_int32_t value)        { flags = value; }
1274
1275         // Conversion functions
1276         DBT *get_DBT()                         { return (DBT *)this; }
1277         const DBT *get_const_DBT() const       { return (const DBT *)this; }
1278
1279         static Dbt* get_Dbt(DBT *dbt)          { return (Dbt *)dbt; }
1280         static const Dbt* get_const_Dbt(const DBT *dbt)
1281                                                { return (const Dbt *)dbt; }
1282
1283         Dbt(void *data, u_int32_t size);
1284         Dbt();
1285         ~Dbt();
1286         Dbt(const Dbt &);
1287         Dbt &operator = (const Dbt &);
1288
1289 private:
1290         // Note: no extra data appears in this class (other than
1291         // inherited from DBT) since we need DBT and Dbt objects
1292         // to have interchangable pointers.
1293         //
1294         // When subclassing this class, remember that callback
1295         // methods like bt_compare, bt_prefix, dup_compare may
1296         // internally manufacture DBT objects (which later are
1297         // cast to Dbt), so such callbacks might receive objects
1298         // not of your subclassed type.
1299 };
1300
1301 ////////////////////////////////////////////////////////////////
1302 ////////////////////////////////////////////////////////////////
1303 //
1304 // multiple key/data/recno iterator classes
1305 //
1306
1307 // DbMultipleIterator is a shared private base class for the three types
1308 // of bulk-return Iterator;  it should never be instantiated directly,
1309 // but it handles the functionality shared by its subclasses.
1310 class _exported DbMultipleIterator
1311 {
1312 public:
1313         DbMultipleIterator(const Dbt &dbt);
1314 protected:
1315         u_int8_t *data_;
1316         u_int32_t *p_;
1317 };
1318
1319 class _exported DbMultipleKeyDataIterator : private DbMultipleIterator
1320 {
1321 public:
1322         DbMultipleKeyDataIterator(const Dbt &dbt) : DbMultipleIterator(dbt) {}
1323         bool next(Dbt &key, Dbt &data);
1324 };
1325
1326 class _exported DbMultipleRecnoDataIterator : private DbMultipleIterator
1327 {
1328 public:
1329         DbMultipleRecnoDataIterator(const Dbt &dbt) : DbMultipleIterator(dbt) {}
1330         bool next(db_recno_t &recno, Dbt &data);
1331 };
1332
1333 class _exported DbMultipleDataIterator : private DbMultipleIterator
1334 {
1335 public:
1336         DbMultipleDataIterator(const Dbt &dbt) : DbMultipleIterator(dbt) {}
1337         bool next(Dbt &data);
1338 };
1339
1340 ////////////////////////////////////////////////////////////////
1341 ////////////////////////////////////////////////////////////////
1342 //
1343 // multiple key/data/recno builder classes
1344 //
1345
1346 // DbMultipleBuilder is a shared private base class for the three types
1347 // of bulk buffer builders;  it should never be instantiated directly,
1348 // but it handles the functionality shared by its subclasses.
1349 class _exported DbMultipleBuilder
1350 {
1351 public:
1352         DbMultipleBuilder(Dbt &dbt);
1353 protected:
1354         Dbt &dbt_;
1355         void *p_;
1356 };
1357
1358 class _exported DbMultipleDataBuilder : DbMultipleBuilder
1359 {
1360 public:
1361         DbMultipleDataBuilder(Dbt &dbt) : DbMultipleBuilder(dbt) {}
1362         bool append(void *dbuf, size_t dlen);
1363         bool reserve(void *&ddest, size_t dlen);
1364 };
1365
1366 class _exported DbMultipleKeyDataBuilder : DbMultipleBuilder
1367 {
1368 public:
1369         DbMultipleKeyDataBuilder(Dbt &dbt) : DbMultipleBuilder(dbt) {}
1370         bool append(void *kbuf, size_t klen, void *dbuf, size_t dlen);
1371         bool reserve(void *&kdest, size_t klen, void *&ddest, size_t dlen);
1372 };
1373
1374 class _exported DbMultipleRecnoDataBuilder
1375 {
1376 public:
1377         DbMultipleRecnoDataBuilder(Dbt &dbt);
1378         bool append(db_recno_t recno, void *dbuf, size_t dlen);
1379         bool reserve(db_recno_t recno, void *&ddest, size_t dlen);
1380 protected:
1381         Dbt &dbt_;
1382         void *p_;
1383 };
1384
1385 ////////////////////////////////////////////////////////////////
1386 ////////////////////////////////////////////////////////////////
1387 //
1388 // Exception classes
1389 //
1390
1391 // Almost any error in the DB library throws a DbException.
1392 // Every exception should be considered an abnormality
1393 // (e.g. bug, misuse of DB, file system error).
1394 //
1395 class _exported DbException : public __DB_STD(exception)
1396 {
1397 public:
1398         virtual ~DbException() throw();
1399         DbException(int err);
1400         DbException(const char *description);
1401         DbException(const char *description, int err);
1402         DbException(const char *prefix, const char *description, int err);
1403         int get_errno() const;
1404         virtual const char *what() const throw();
1405         DbEnv *get_env() const;
1406         void set_env(DbEnv *dbenv);
1407
1408         DbException(const DbException &);
1409         DbException &operator = (const DbException &);
1410
1411 private:
1412         void describe(const char *prefix, const char *description);
1413
1414         char *what_;
1415         int err_;                   // errno
1416         DbEnv *dbenv_;
1417 };
1418
1419 //
1420 // A specific sort of exception that occurs when
1421 // an operation is aborted to resolve a deadlock.
1422 //
1423 class _exported DbDeadlockException : public DbException
1424 {
1425 public:
1426         virtual ~DbDeadlockException() throw();
1427         DbDeadlockException(const char *description);
1428
1429         DbDeadlockException(const DbDeadlockException &);
1430         DbDeadlockException &operator = (const DbDeadlockException &);
1431 };
1432
1433 //
1434 // A specific sort of exception that occurs when
1435 // a lock is not granted, e.g. by lock_get or lock_vec.
1436 // Note that the Dbt is only live as long as the Dbt used
1437 // in the offending call.
1438 //
1439 class _exported DbLockNotGrantedException : public DbException
1440 {
1441 public:
1442         virtual ~DbLockNotGrantedException() throw();
1443         DbLockNotGrantedException(const char *prefix, db_lockop_t op,
1444             db_lockmode_t mode, const Dbt *obj, const DbLock lock, int index);
1445         DbLockNotGrantedException(const char *description);
1446
1447         DbLockNotGrantedException(const DbLockNotGrantedException &);
1448         DbLockNotGrantedException &operator =
1449             (const DbLockNotGrantedException &);
1450
1451         db_lockop_t get_op() const;
1452         db_lockmode_t get_mode() const;
1453         const Dbt* get_obj() const;
1454         DbLock *get_lock() const;
1455         int get_index() const;
1456
1457 private:
1458         db_lockop_t op_;
1459         db_lockmode_t mode_;
1460         const Dbt *obj_;
1461         DbLock *lock_;
1462         int index_;
1463 };
1464
1465 //
1466 // A specific sort of exception that occurs when
1467 // user declared memory is insufficient in a Dbt.
1468 //
1469 class _exported DbMemoryException : public DbException
1470 {
1471 public:
1472         virtual ~DbMemoryException() throw();
1473         DbMemoryException(Dbt *dbt);
1474         DbMemoryException(const char *prefix, Dbt *dbt);
1475
1476         DbMemoryException(const DbMemoryException &);
1477         DbMemoryException &operator = (const DbMemoryException &);
1478
1479         Dbt *get_dbt() const;
1480 private:
1481         Dbt *dbt_;
1482 };
1483
1484 //
1485 // A specific sort of exception that occurs when a change of replication
1486 // master requires that all handles be re-opened.
1487 //
1488 class _exported DbRepHandleDeadException : public DbException
1489 {
1490 public:
1491         virtual ~DbRepHandleDeadException() throw();
1492         DbRepHandleDeadException(const char *description);
1493
1494         DbRepHandleDeadException(const DbRepHandleDeadException &);
1495         DbRepHandleDeadException &operator = (const DbRepHandleDeadException &);
1496 };
1497
1498 //
1499 // A specific sort of exception that occurs when
1500 // recovery is required before continuing DB activity.
1501 //
1502 class _exported DbRunRecoveryException : public DbException
1503 {
1504 public:
1505         virtual ~DbRunRecoveryException() throw();
1506         DbRunRecoveryException(const char *description);
1507
1508         DbRunRecoveryException(const DbRunRecoveryException &);
1509         DbRunRecoveryException &operator = (const DbRunRecoveryException &);
1510 };
1511
1512 //
1513 // A specific sort of exception that occurs when
1514
1515 ////////////////////////////////////////////////////////////////
1516 ////////////////////////////////////////////////////////////////
1517 //
1518 // Restore default compiler warnings
1519 //
1520 #ifdef _MSC_VER
1521 #pragma warning(pop)
1522 #endif
1523
1524 #endif /* !_DB_CXX_H_ */