Update from db-2.3.12.
[kopensolaris-gnu/glibc.git] / db2 / include / db_cxx.h
1 /*-
2  * See the file LICENSE for redistribution information.
3  *
4  * Copyright (c) 1997
5  *      Sleepycat Software.  All rights reserved.
6  *
7  *      @(#)db_cxx.h    10.12 (Sleepycat) 10/25/97
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, see setErrorModel().
21 //
22 // C++ naming conventions:
23 //
24 //  - All top level class names start with Db.
25 //  - All class members start with lower case letter.
26 //  - All private data members are suffixed with underscore.
27 //  - Use underscores to divide names into multiple words.
28 //  - Simple data accessors are named with get_ or set_ prefix.
29 //  - All method names are taken from names of functions in the C
30 //    layer of db (usually by dropping a prefix like "db_").
31 //    These methods have the same argument types and order,
32 //    other than dropping the explicit arg that acts as "this".
33 //
34 // As a rule, each DbFoo object has exactly one underlying DB_FOO struct
35 // (defined in db.h) associated with it.  In many cases, we inherit directly
36 // from the DB_FOO structure to make this relationship explicit.  Often,
37 // the underlying C layer allocates and deallocates these structures, so
38 // there is no easy way to add any data to the DbFoo class.  When you see
39 // a comment about whether data is permitted to be added, this is what
40 // is going on.  Of course, if we need to add data to such C++ classes
41 // in the future, we will arrange to have an indirect pointer to the
42 // DB_FOO struct (as some of the classes already have).
43 //
44
45
46 ////////////////////////////////////////////////////////////////
47 ////////////////////////////////////////////////////////////////
48 //
49 // Forward declarations
50 //
51
52 #include "db.h"
53
54 class Db;                                        // forward
55 class Dbc;                                       // forward
56 class DbEnv;                                     // forward
57 class DbException;                               // forward
58 class DbInfo;                                    // forward
59 class DbLock;                                    // forward
60 class DbLockTab;                                 // forward
61 class DbLog;                                     // forward
62 class DbLsn;                                     // forward
63 class DbMpool;                                   // forward
64 class DbMpoolFile;                               // forward
65 class Dbt;                                       // forward
66 class DbTxn;                                     // forward
67 class DbTxnMgr;                                  // forward
68
69 ////////////////////////////////////////////////////////////////
70 ////////////////////////////////////////////////////////////////
71 //
72 // Mechanisms for declaring classes
73 //
74
75 //
76 // Every class defined in this file has an _exported next to the class name.
77 // This is needed for WinTel machines so that the class methods can
78 // be exported or imported in a DLL as appropriate.  Users of the DLL
79 // use the define DB_USE_DLL.  When the DLL is built, DB_CREATE_DLL
80 // must be defined.
81 //
82 #if defined(_MSC_VER)
83
84 #  if defined(DB_CREATE_DLL)
85 #    define _exported __declspec(dllexport)      // creator of dll
86 #  elif defined(DB_USE_DLL)
87 #    define _exported __declspec(dllimport)      // user of dll
88 #  else
89 #    define _exported                            // static lib creator or user
90 #  endif
91
92 #else
93
94 #  define _exported
95
96 #endif
97
98 // DEFINE_DB_CLASS defines an imp_ data member and imp() accessor.
99 // The underlying type is a pointer to an opaque *Imp class, that
100 // gets converted to the correct implementation class by the implementation.
101 //
102 // Since these defines use "private/public" labels, and leave the access
103 // being "private", we always use these by convention before any data
104 // members in the private section of a class.  Keeping them in the
105 // private section also emphasizes that they are off limits to user code.
106 //
107 #define DEFINE_DB_CLASS(name) \
108     public: class name##Imp* imp() { return imp_; } \
109     public: const class name##Imp* imp() const { return imp_; } \
110     private: class name##Imp* imp_
111
112
113 ////////////////////////////////////////////////////////////////
114 ////////////////////////////////////////////////////////////////
115 //
116 // Turn off inappropriate compiler warnings
117 //
118
119 #ifdef _MSC_VER
120
121 // These are level 4 warnings that are explicitly disabled.
122 // With Visual C++, by default you do not see above level 3 unless
123 // you use /W4.  But we like to compile with the highest level
124 // warnings to catch other errors.
125 //
126 // 4201: nameless struct/union
127 //       triggered by standard include file <winnt.h>
128 //
129 // 4514: unreferenced inline function has been removed
130 //       certain include files in MSVC define methods that are not called
131 //
132 #pragma warning(disable: 4201 4514)
133
134 #endif
135
136 ////////////////////////////////////////////////////////////////
137 ////////////////////////////////////////////////////////////////
138 //
139 // Exception classes
140 //
141
142 // Almost any error in the DB library throws a DbException.
143 // Every exception should be considered an abnormality
144 // (e.g. bug, misuse of DB, file system error).
145 //
146 // NOTE: We would like to inherit from class exception and
147 //       let it handle what(), but there are
148 //       MSVC++ problems when <exception> is included.
149 //
150 class _exported DbException
151 {
152 public:
153     virtual ~DbException();
154     DbException(int err);
155     DbException(const char *description);
156     DbException(const char *prefix, int err);
157     DbException(const char *prefix1, const char *prefix2, int err);
158     const int get_errno();
159     virtual const char *what() const;
160
161     DbException(const DbException &);
162     DbException &operator = (const DbException &);
163
164 private:
165     char *what_;
166     int err_;                   // errno
167 };
168
169
170 ////////////////////////////////////////////////////////////////
171 ////////////////////////////////////////////////////////////////
172 //
173 // Lock classes
174 //
175
176 class _exported DbLock
177 {
178     friend DbLockTab;
179
180 public:
181     DbLock(unsigned int);
182     DbLock();
183
184     unsigned int get_lock_id();
185     void set_lock_id(unsigned int);
186
187     int put(DbLockTab *locktab);
188
189     DbLock(const DbLock &);
190     DbLock &operator = (const DbLock &);
191
192 protected:
193     // We can add data to this class if needed
194     // since its contained class is not allocated by db.
195     // (see comment at top)
196
197     DB_LOCK lock_;
198 };
199
200 class _exported DbLockTab
201 {
202 friend DbEnv;
203 public:
204     int close();
205     int detect(int atype, u_int32_t flags);
206     int get(u_int32_t locker, int flags, const Dbt *obj,
207             db_lockmode_t lock_mode, DbLock *lock);
208     int id(u_int32_t *idp);
209     int vec(u_int32_t locker, int flags, DB_LOCKREQ list[],
210             int nlist, DB_LOCKREQ **elistp);
211
212     // Create or remove new locktab files
213     //
214     static int open(const char *dir, int flags, int mode,
215                     DbEnv* dbenv, DbLockTab **regionp);
216     static int unlink(const char *dir, int force, DbEnv* dbenv);
217
218 private:
219     // We can add data to this class if needed
220     // since it is implemented via a pointer.
221     // (see comment at top)
222
223     // copying not allowed
224     //
225     DbLockTab(const DbLockTab &);
226     DbLockTab &operator = (const DbLockTab &);
227
228     // Note: use DbLockTab::open() or DbEnv::get_lk_info()
229     // to get pointers to a DbLockTab,
230     // and call DbLockTab::close() rather than delete to release them.
231     //
232     DbLockTab();
233     ~DbLockTab();
234
235     DEFINE_DB_CLASS(DbLockTab);
236 };
237
238
239 ////////////////////////////////////////////////////////////////
240 ////////////////////////////////////////////////////////////////
241 //
242 // Log classes
243 //
244
245 class _exported DbLsn : protected DB_LSN
246 {
247     friend DbLog;               // friendship needed to cast to base class
248     friend DbMpool;
249 };
250
251 class _exported DbLog
252 {
253 friend DbEnv;
254 public:
255     int archive(char **list[], int flags, void *(*db_malloc)(size_t));
256     int close();
257     static int compare(const DbLsn *lsn0, const DbLsn *lsn1);
258     int file(DbLsn *lsn, char *namep, int len);
259     int flush(const DbLsn *lsn);
260     int get(DbLsn *lsn, Dbt *data, int flags);
261     int put(DbLsn *lsn, const Dbt *data, int flags);
262
263     // Normally these would be called register and unregister to
264     // parallel the C interface, but "register" is a reserved word.
265     //
266     int db_register(Db *dbp, const char *name, DBTYPE type, u_int32_t *fidp);
267     int db_unregister(u_int32_t fid);
268
269     // Create or remove new log files
270     //
271     static int open(const char *dir, int flags, int mode,
272                     DbEnv* dbenv, DbLog **regionp);
273     static int unlink(const char *dir, int force, DbEnv* dbenv);
274
275 private:
276     // We can add data to this class if needed
277     // since it is implemented via a pointer.
278     // (see comment at top)
279
280     // Note: use DbLog::open() or DbEnv::get_lg_info()
281     // to get pointers to a DbLog,
282     // and call DbLog::close() rather than delete to release them.
283     //
284     DbLog();
285     ~DbLog();
286
287     // no copying
288     DbLog(const DbLog &);
289     operator = (const DbLog &);
290
291     DEFINE_DB_CLASS(DbLog);
292 };
293
294
295 ////////////////////////////////////////////////////////////////
296 ////////////////////////////////////////////////////////////////
297 //
298 // Memory pool classes
299 //
300
301 class _exported DbMpoolFile
302 {
303 public:
304     int close();
305     int get(db_pgno_t *pgnoaddr, int flags, void *pagep);
306     int put(void *pgaddr, int flags);
307     int set(void *pgaddr, int flags);
308     int sync();
309
310     static int open(DbMpool *mp, const char *file,
311                     int ftype, int flags, int mode,
312                     size_t pagesize, int lsn_offset,
313                     Dbt *pgcookie, u_int8_t *uid, DbMpoolFile **mpf);
314
315 private:
316     // We can add data to this class if needed
317     // since it is implemented via a pointer.
318     // (see comment at top)
319
320     // Note: use DbMpoolFile::open()
321     // to get pointers to a DbMpoolFile,
322     // and call DbMpoolFile::close() rather than delete to release them.
323     //
324     DbMpoolFile();
325
326     // Shut g++ up.
327 protected:
328     ~DbMpoolFile();
329
330 private:
331     // no copying
332     DbMpoolFile(const DbMpoolFile &);
333     operator = (const DbMpoolFile &);
334
335     DEFINE_DB_CLASS(DbMpoolFile);
336 };
337
338 class _exported DbMpool
339 {
340 friend DbEnv;
341 public:
342     int close();
343
344     // access to low level interface
345     // Normally this would be called register to parallel
346     // the C interface, but "register" is a reserved word.
347     //
348     int db_register(int ftype,
349                     int (*pgin)(db_pgno_t pgno, void *pgaddr, DBT *pgcookie),
350                     int (*pgout)(db_pgno_t pgno, void *pgaddr, DBT *pgcookie));
351
352     int stat(DB_MPOOL_STAT **gsp, DB_MPOOL_FSTAT ***fsp,
353              void *(*db_malloc)(size_t));
354     int sync(DbLsn *lsn);
355     int trickle(int pct, int *nwrotep);
356
357     // Create or remove new mpool files
358     //
359     static int open(const char *dir, int flags, int mode,
360                     DbEnv* dbenv, DbMpool **regionp);
361     static int unlink(const char *dir, int force, DbEnv* dbenv);
362
363 private:
364     // We can add data to this class if needed
365     // since it is implemented via a pointer.
366     // (see comment at top)
367
368     // Note: use DbMpool::open() or DbEnv::get_mp_info()
369     // to get pointers to a DbMpool,
370     // and call DbMpool::close() rather than delete to release them.
371     //
372     DbMpool();
373     ~DbMpool();
374
375     // no copying
376     DbMpool(const DbMpool &);
377     DbMpool &operator = (const DbMpool &);
378
379     DEFINE_DB_CLASS(DbMpool);
380 };
381
382
383 ////////////////////////////////////////////////////////////////
384 ////////////////////////////////////////////////////////////////
385 //
386 // Transaction classes
387 //
388
389 class _exported DbTxnMgr
390 {
391 friend DbEnv;
392 public:
393     int begin(DbTxn *pid, DbTxn **tid);
394     int checkpoint(int kbyte, int min) const;
395     int close();
396     int stat(DB_TXN_STAT **statp, void *(*db_malloc)(size_t));
397
398     // Create or remove new txnmgr files
399     //
400     static int open(const char *dir, int flags, int mode,
401                     DbEnv* dbenv, DbTxnMgr **regionp);
402     static int unlink(const char *dir, int force, DbEnv* dbenv);
403
404 private:
405     // We can add data to this class if needed
406     // since it is implemented via a pointer.
407     // (see comment at top)
408
409     // Note: use DbTxnMgr::open() or DbEnv::get_tx_info()
410     // to get pointers to a DbTxnMgr,
411     // and call DbTxnMgr::close() rather than delete to release them.
412     //
413     DbTxnMgr();
414     ~DbTxnMgr();
415
416     // no copying
417     DbTxnMgr(const DbTxnMgr &);
418     operator = (const DbTxnMgr &);
419
420     DEFINE_DB_CLASS(DbTxnMgr);
421 };
422
423 class _exported DbTxn
424 {
425 friend DbTxnMgr;
426 public:
427     int abort();
428     int commit();
429     u_int32_t id();
430     int prepare();
431
432 private:
433     // We can add data to this class if needed
434     // since it is implemented via a pointer.
435     // (see comment at top)
436
437     // Note: use DbTxnMgr::begin() to get pointers to a DbTxn,
438     // and call DbTxn::abort() or DbTxn::commit rather than
439     // delete to release them.
440     //
441     DbTxn();
442     ~DbTxn();
443
444     // no copying
445     DbTxn(const DbTxn &);
446     operator = (const DbTxn &);
447
448     DEFINE_DB_CLASS(DbTxn);
449 };
450
451
452 ////////////////////////////////////////////////////////////////
453 ////////////////////////////////////////////////////////////////
454 //
455 // Application classes
456 //
457
458 //
459 // A set of application options - define how this application uses
460 // the db library.
461 //
462 class _exported DbInfo : protected DB_INFO
463 {
464     friend DbEnv;
465     friend Db;
466
467 public:
468     DbInfo();
469     ~DbInfo();
470
471     // Byte order.
472     int get_lorder() const;
473     void set_lorder(int);
474
475     // Underlying cache size.
476     size_t get_cachesize() const;
477     void set_cachesize(size_t);
478
479     // Underlying page size.
480     size_t get_pagesize() const;
481     void set_pagesize(size_t);
482
483     // Local heap allocation.
484     typedef void *(*db_malloc_fcn)(size_t);
485     db_malloc_fcn get_malloc() const;
486     void set_malloc(db_malloc_fcn);
487
488     ////////////////////////////////////////////////////////////////
489     // Btree access method.
490
491     // Maximum keys per page.
492     int get_bt_maxkey() const;
493     void set_bt_maxkey(int);
494
495     // Minimum keys per page.
496     int get_bt_minkey() const;
497     void set_bt_minkey(int);
498
499     // Comparison function.
500     typedef int (*bt_compare_fcn)(const DBT *, const DBT *);
501     bt_compare_fcn get_bt_compare() const;
502     void set_bt_compare(bt_compare_fcn);
503
504     // Prefix function.
505     typedef size_t (*bt_prefix_fcn)(const DBT *, const DBT *);
506     bt_prefix_fcn get_bt_prefix() const;
507     void set_bt_prefix(bt_prefix_fcn);
508
509     ////////////////////////////////////////////////////////////////
510     // Hash access method.
511
512     // Fill factor.
513     unsigned int get_h_ffactor() const;
514     void set_h_ffactor(unsigned int);
515
516     // Number of elements.
517     unsigned int get_h_nelem() const;
518     void set_h_nelem(unsigned int);
519
520     // Hash function.
521     typedef u_int32_t (*h_hash_fcn)(const void *, u_int32_t);
522     h_hash_fcn get_h_hash() const;
523     void set_h_hash(h_hash_fcn);
524
525     ////////////////////////////////////////////////////////////////
526     // Recno access method.
527
528     // Fixed-length padding byte.
529     int get_re_pad() const;
530     void set_re_pad(int);
531
532     // Variable-length delimiting byte.
533     int get_re_delim() const;
534     void set_re_delim(int);
535
536     // Length for fixed-length records.
537     u_int32_t get_re_len() const;
538     void set_re_len(u_int32_t);
539
540     // Source file name.
541     char *get_re_source() const;
542     void set_re_source(char *);
543
544     // Note: some flags are set as side effects of calling
545     // above "set" methods.
546     //
547     u_int32_t get_flags() const;
548     void set_flags(u_int32_t);
549
550
551     // (deep) copying of this object is allowed.
552     //
553     DbInfo(const DbInfo &);
554     DbInfo &operator = (const DbInfo &);
555
556 private:
557     // We can add data to this class if needed
558     // since parent class is not allocated by db.
559     // (see comment at top)
560 };
561
562 //
563 // Base application class.  Provides functions for opening a database.
564 // User of this library can use this class as a starting point for
565 // developing a DB application - derive their application class from
566 // this one, add application control logic.
567 //
568 // Note that if you use the default constructor, you must explicitly
569 // call appinit() before any other db activity (e.g. opening files)
570 //
571 class _exported DbEnv : protected DB_ENV
572 {
573 friend DbTxnMgr;
574 friend DbLog;
575 friend DbLockTab;
576 friend DbMpool;
577 friend Db;
578
579 public:
580
581     ~DbEnv();
582
583     // This constructor can be used to immediately initialize the
584     // application with these arguments.  Do not use it if you
585     // need to set other parameters via the access methods.
586     //
587     DbEnv(const char *homeDir, char *const *db_config, int flags);
588
589     // Use this constructor if you wish to *delay* the initialization
590     // of the db library.  This is useful if you need to set
591     // any particular parameters via the access methods below.
592     // Then call appinit() to complete the initialization.
593     //
594     DbEnv();
595
596     // Used in conjunction with the default constructor to
597     // complete the initialization of the db library.
598     //
599     int appinit(const char *homeDir, char *const *db_config, int flags);
600
601     // Called automatically when DbEnv is destroyed, or can be
602     // called at any time to shut down Db.
603     //
604     int appexit();
605
606     ////////////////////////////////////////////////////////////////
607     // simple get/set access methods
608     //
609     // If you are calling set_ methods, you need to
610     // use the default constructor along with appinit().
611
612     // Byte order.
613     int get_lorder() const;
614     void set_lorder(int);
615
616     // Error message callback.
617     typedef void (*db_errcall_fcn)(const char *, char *);
618     db_errcall_fcn get_errcall() const;
619     void set_errcall(db_errcall_fcn);
620
621     // Error message file stream.
622     FILE *get_errfile() const;
623     void set_errfile(FILE *);
624
625     // Error message prefix.
626     const char *get_errpfx() const;
627     void set_errpfx(const char *);
628
629     // Generate debugging messages.
630     int get_verbose() const;
631     void set_verbose(int);
632
633     ////////////////////////////////////////////////////////////////
634     // User paths.
635
636     // Database home.
637     char *get_home() const;
638     void set_home(char *);
639
640     // Database log file directory.
641     char *get_log_dir() const;
642     void set_log_dir(char *);
643
644     // Database tmp file directory.
645     char *get_tmp_dir() const;
646     void set_tmp_dir(char *);
647
648     // Database data file directories.
649     char **get_data_dir() const;
650     void set_data_dir(char **);
651
652     // Database data file slots.
653     int get_data_cnt() const;
654     void set_data_cnt(int);
655
656     // Next Database data file slot.
657     int get_data_next() const;
658     void set_data_next(int);
659
660
661     ////////////////////////////////////////////////////////////////
662     // Locking.
663
664     // Return from lock_open().
665     DbLockTab *get_lk_info() const;
666
667     // Two dimensional conflict matrix.
668     u_int8_t *get_lk_conflicts() const;
669     void set_lk_conflicts(u_int8_t *);
670
671     // Number of lock modes in table.
672     int get_lk_modes() const;
673     void set_lk_modes(int);
674
675     // Maximum number of locks.
676     unsigned int get_lk_max() const;
677     void set_lk_max(unsigned int);
678
679     // Deadlock detect on every conflict.
680     u_int32_t get_lk_detect() const;
681     void set_lk_detect(u_int32_t);
682
683
684     ////////////////////////////////////////////////////////////////
685     // Logging.
686
687     // Return from log_open().
688     DbLog *get_lg_info() const;
689
690     // Maximum file size.
691     u_int32_t get_lg_max() const;
692     void set_lg_max(u_int32_t);
693
694
695     ////////////////////////////////////////////////////////////////
696     // Memory pool.
697
698     // Return from memp_open().
699     DbMpool *get_mp_info() const;
700
701     // Maximum file size for mmap.
702     size_t get_mp_mmapsize() const;
703     void set_mp_mmapsize(size_t);
704
705     // Bytes in the mpool cache.
706     size_t get_mp_size() const;
707     void set_mp_size(size_t);
708
709
710     ////////////////////////////////////////////////////////////////
711     // Transactions.
712
713     // Return from txn_open().
714     DbTxnMgr *get_tx_info() const;
715
716     // Maximum number of transactions.
717     unsigned int get_tx_max() const;
718     void set_tx_max(unsigned int);
719
720     // Dispatch function for recovery.
721     typedef int (*tx_recover_fcn)(DB_LOG *, DBT *, DB_LSN *, int, void *);
722     tx_recover_fcn get_tx_recover() const;
723     void set_tx_recover(tx_recover_fcn);
724
725     // Flags.
726     u_int32_t get_flags() const;
727     void set_flags(u_int32_t);
728
729     ////////////////////////////////////////////////////////////////
730     // The default error model is to throw an exception whenever
731     // an error occurs.  This generally allows for cleaner logic
732     // for transaction processing, as a try block can surround a
733     // single transaction.  Alternatively, since almost every method
734     // returns an error code (errno), the error model can be set to
735     // not throw exceptions, and instead return the appropriate code.
736     //
737     enum ErrorModel { Exception, ErrorReturn };
738     void set_error_model(ErrorModel);
739     ErrorModel get_error_model() const;
740
741     // If an error is detected and the error call function
742     // or stream is set, a message is dispatched or printed.
743     // If a prefix is set, each message is prefixed.
744     //
745     // You can use set_errcall() or set_errfile() above to control
746     // error functionality using a C model.  Alternatively, you can
747     // call set_error_stream() to force all errors to a C++ stream.
748     // It is unwise to mix these approaches.
749     //
750     class ostream* get_error_stream() const;
751     void set_error_stream(class ostream*);
752
753     // used internally
754     static int runtime_error(const char *caller, int err, int in_destructor = 0);
755
756 private:
757     // We can add data to this class if needed
758     // since parent class is not allocated by db.
759     // (see comment at top)
760
761     // no copying
762     DbEnv(const DbEnv &);
763     operator = (const DbEnv &);
764
765     ErrorModel error_model_;
766     static void stream_error_function(const char *, char *);
767     static ostream *error_stream_;
768 };
769
770 ////////////////////////////////////////////////////////////////
771 ////////////////////////////////////////////////////////////////
772 //
773 // Table access classes
774 //
775
776 //
777 // Represents a database table = a set of keys with associated values.
778 //
779 class _exported Db
780 {
781     friend DbEnv;
782
783 public:
784     int close(int flags);
785     int cursor(DbTxn *txnid, Dbc **cursorp);
786     int del(DbTxn *txnid, Dbt *key, int flags);
787     int fd(int *fdp);
788     int get(DbTxn *txnid, Dbt *key, Dbt *data, int flags);
789     int put(DbTxn *txnid, Dbt *key, Dbt *data, int flags);
790     int stat(void *sp, void *(*db_malloc)(size_t), int flags);
791     int sync(int flags);
792
793     DBTYPE get_type() const;
794
795     static int open(const char *fname, DBTYPE type, int flags,
796                     int mode, DbEnv *dbenv, DbInfo *info, Db **dbpp);
797
798 private:
799     // We can add data to this class if needed
800     // since it is implemented via a pointer.
801     // (see comment at top)
802
803     // Note: use Db::open() to get initialize pointers to a Db,
804     // and call Db::close() rather than delete to release them.
805     Db();
806     ~Db();
807
808     // no copying
809     Db(const Db &);
810     Db &operator = (const Db &);
811
812     DEFINE_DB_CLASS(Db);
813 };
814
815 //
816 // A chunk of data, maybe a key or value.
817 //
818 class _exported Dbt : private DBT
819 {
820     friend Dbc;
821     friend Db;
822     friend DbLog;
823     friend DbMpoolFile;
824     friend DbLockTab;
825
826 public:
827
828     // key/data
829     void *get_data() const;
830     void set_data(void *);
831
832     // key/data length
833     u_int32_t get_size() const;
834     void set_size(u_int32_t);
835
836     // RO: length of user buffer.
837     u_int32_t get_ulen() const;
838     void set_ulen(u_int32_t);
839
840     // RO: get/put record length.
841     u_int32_t get_dlen() const;
842     void set_dlen(u_int32_t);
843
844     // RO: get/put record offset.
845     u_int32_t get_doff() const;
846     void set_doff(u_int32_t);
847
848     // flags
849     u_int32_t get_flags() const;
850     void set_flags(u_int32_t);
851
852     Dbt(void *data, size_t size);
853     Dbt();
854     ~Dbt();
855     Dbt(const Dbt &);
856     Dbt &operator = (const Dbt &);
857
858 private:
859     // We can add data to this class if needed
860     // since parent class is not allocated by db.
861     // (see comment at top)
862 };
863
864 class _exported Dbc : protected DBC
865 {
866     friend Db;
867
868 public:
869     int close();
870     int del(int flags);
871     int get(Dbt* key, Dbt *data, int flags);
872     int put(Dbt* key, Dbt *data, int flags);
873
874 private:
875     // No data is permitted in this class (see comment at top)
876
877     // Note: use Db::cursor() to get pointers to a Dbc,
878     // and call Dbc::close() rather than delete to release them.
879     //
880     Dbc();
881     ~Dbc();
882
883     // no copying
884     Dbc(const Dbc &);
885     Dbc &operator = (const Dbc &);
886 };
887 #endif /* !_DB_CXX_H_ */