diff options
Diffstat (limited to 'plugins/Dbx_kyoto/src/kyotocabinet/kcdb.h')
| -rw-r--r-- | plugins/Dbx_kyoto/src/kyotocabinet/kcdb.h | 2520 |
1 files changed, 2520 insertions, 0 deletions
diff --git a/plugins/Dbx_kyoto/src/kyotocabinet/kcdb.h b/plugins/Dbx_kyoto/src/kyotocabinet/kcdb.h new file mode 100644 index 0000000000..8abffb4c6b --- /dev/null +++ b/plugins/Dbx_kyoto/src/kyotocabinet/kcdb.h @@ -0,0 +1,2520 @@ +/************************************************************************************************* + * Database interface + * Copyright (C) 2009-2012 FAL Labs + * This file is part of Kyoto Cabinet. + * This program is free software: you can redistribute it and/or modify it under the terms of + * the GNU General Public License as published by the Free Software Foundation, either version + * 3 of the License, or any later version. + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * You should have received a copy of the GNU General Public License along with this program. + * If not, see <http://www.gnu.org/licenses/>. + *************************************************************************************************/ + + +#ifndef _KCDB_H // duplication check +#define _KCDB_H + +#include <kccommon.h> +#include <kcutil.h> +#include <kcthread.h> +#include <kcfile.h> +#include <kccompress.h> +#include <kccompare.h> +#include <kcmap.h> + +#define KCDBSSMAGICDATA "KCSS\n" ///< The magic data of the snapshot file + +namespace kyotocabinet { // common namespace + + +/** + * Interface of database abstraction. + * @note This class is an abstract class to prescribe the interface of record access. + */ +class DB { + public: + /** + * Interface to access a record. + */ + class Visitor { + public: + /** Special pointer for no operation. */ + static const char* const NOP; + /** Special pointer to remove the record. */ + static const char* const REMOVE; + /** + * Destructor. + */ + virtual ~Visitor() { + _assert_(true); + } + /** + * Visit a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @return If it is the pointer to a region, the value is replaced by the content. If it + * is Visitor::NOP, nothing is modified. If it is Visitor::REMOVE, the record is removed. + */ + virtual const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ && sp); + return NOP; + } + /** + * Visit a empty record space. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @return If it is the pointer to a region, the value is replaced by the content. If it + * is Visitor::NOP or Visitor::REMOVE, nothing is modified. + */ + virtual const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && sp); + return NOP; + } + /** + * Preprocess the main operations. + */ + virtual void visit_before() { + _assert_(true); + } + /** + * Postprocess the main operations. + */ + virtual void visit_after() { + _assert_(true); + } + }; + /** + * Interface of cursor to indicate a record. + */ + class Cursor { + public: + /** + * Destructor. + */ + virtual ~Cursor() { + _assert_(true); + } + /** + * Accept a visitor to the current record. + * @param visitor a visitor object. + * @param writable true for writable operation, or false for read-only operation. + * @param step true to move the cursor to the next record, or false for no move. + * @return true on success, or false on failure. + * @note The operation for each record is performed atomically and other threads accessing + * the same record are blocked. To avoid deadlock, any explicit database operation must not + * be performed in this function. + */ + virtual bool accept(Visitor* visitor, bool writable = true, bool step = false) = 0; + /** + * Set the value of the current record. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @param step true to move the cursor to the next record, or false for no move. + * @return true on success, or false on failure. + */ + virtual bool set_value(const char* vbuf, size_t vsiz, bool step = false) = 0; + /** + * Set the value of the current record. + * @note Equal to the original Cursor::set_value method except that the parameter is + * std::string. + */ + virtual bool set_value_str(const std::string& value, bool step = false) = 0; + /** + * Remove the current record. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, false is returned. The cursor is moved to the + * next record implicitly. + */ + virtual bool remove() = 0; + /** + * Get the key of the current record. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @param step true to move the cursor to the next record, or false for no move. + * @return the pointer to the key region of the current record, or NULL on failure. + * @note If the cursor is invalidated, NULL is returned. Because an additional zero + * code is appended at the end of the region of the return value, the return value can be + * treated as a C-style string. Because the region of the return value is allocated with the + * the new[] operator, it should be released with the delete[] operator when it is no longer + * in use. + */ + virtual char* get_key(size_t* sp, bool step = false) = 0; + /** + * Get the key of the current record. + * @note Equal to the original Cursor::get_key method except that a parameter is a string to + * contain the result and the return value is bool for success. + */ + virtual bool get_key(std::string* key, bool step = false) = 0; + /** + * Get the value of the current record. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @param step true to move the cursor to the next record, or false for no move. + * @return the pointer to the value region of the current record, or NULL on failure. + * @note If the cursor is invalidated, NULL is returned. Because an additional zero + * code is appended at the end of the region of the return value, the return value can be + * treated as a C-style string. Because the region of the return value is allocated with the + * the new[] operator, it should be released with the delete[] operator when it is no longer + * in use. + */ + virtual char* get_value(size_t* sp, bool step = false) = 0; + /** + * Get the value of the current record. + * @note Equal to the original Cursor::get_value method except that a parameter is a string + * to contain the result and the return value is bool for success. + */ + virtual bool get_value(std::string* value, bool step = false) = 0; + /** + * Get a pair of the key and the value of the current record. + * @param ksp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @param vbp the pointer to the variable into which the pointer to the value region is + * assigned. + * @param vsp the pointer to the variable into which the size of the value region is + * assigned. + * @param step true to move the cursor to the next record, or false for no move. + * @return the pointer to the key region, or NULL on failure. + * @note If the cursor is invalidated, NULL is returned. Because an additional zero code is + * appended at the end of each region of the key and the value, each region can be treated + * as a C-style string. The return value should be deleted explicitly by the caller with + * the detele[] operator. + */ + virtual char* get(size_t* ksp, const char** vbp, size_t* vsp, bool step = false) = 0; + /** + * Get a pair of the key and the value of the current record. + * @note Equal to the original Cursor::get method except that parameters are strings + * to contain the result and the return value is bool for success. + */ + virtual bool get(std::string* key, std::string* value, bool step = false) = 0; + /** + * Jump the cursor to the first record for forward scan. + * @return true on success, or false on failure. + */ + virtual bool jump() = 0; + /** + * Jump the cursor to a record for forward scan. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @return true on success, or false on failure. + */ + virtual bool jump(const char* kbuf, size_t ksiz) = 0; + /** + * Jump the cursor to a record for forward scan. + * @note Equal to the original Cursor::jump method except that the parameter is std::string. + */ + virtual bool jump(const std::string& key) = 0; + /** + * Jump the cursor to the last record for backward scan. + * @return true on success, or false on failure. + * @note This method is dedicated to tree databases. Some database types, especially hash + * databases, will provide a dummy implementation. + */ + virtual bool jump_back() = 0; + /** + * Jump the cursor to a record for backward scan. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @return true on success, or false on failure. + * @note This method is dedicated to tree databases. Some database types, especially hash + * databases, will provide a dummy implementation. + */ + virtual bool jump_back(const char* kbuf, size_t ksiz) = 0; + /** + * Jump the cursor to a record for backward scan. + * @note Equal to the original Cursor::jump_back method except that the parameter is + * std::string. + */ + virtual bool jump_back(const std::string& key) = 0; + /** + * Step the cursor to the next record. + * @return true on success, or false on failure. + */ + virtual bool step() = 0; + /** + * Step the cursor to the previous record. + * @return true on success, or false on failure. + * @note This method is dedicated to tree databases. Some database types, especially hash + * databases, will provide a dummy implementation. + */ + virtual bool step_back() = 0; + /** + * Get the database object. + * @return the database object. + */ + virtual DB* db() = 0; + }; + /** + * Destructor. + */ + virtual ~DB() { + _assert_(true); + } + /** + * Accept a visitor to a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param visitor a visitor object. + * @param writable true for writable operation, or false for read-only operation. + * @return true on success, or false on failure. + * @note The operation for each record is performed atomically and other threads accessing the + * same record are blocked. To avoid deadlock, any explicit database operation must not be + * performed in this function. + */ + virtual bool accept(const char* kbuf, size_t ksiz, Visitor* visitor, bool writable = true) = 0; + /** + * Set the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, a new record is created. If the corresponding + * record exists, the value is overwritten. + */ + virtual bool set(const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) = 0; + /** + * Set the value of a record. + * @note Equal to the original DB::set method except that the parameters are std::string. + */ + virtual bool set(const std::string& key, const std::string& value) = 0; + /** + * Add a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, a new record is created. If the corresponding + * record exists, the record is not modified and false is returned. + */ + virtual bool add(const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) = 0; + /** + * Set the value of a record. + * @note Equal to the original DB::add method except that the parameters are std::string. + */ + virtual bool add(const std::string& key, const std::string& value) = 0; + /** + * Replace the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, no new record is created and false is returned. + * If the corresponding record exists, the value is modified. + */ + virtual bool replace(const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) = 0; + /** + * Replace the value of a record. + * @note Equal to the original DB::replace method except that the parameters are std::string. + */ + virtual bool replace(const std::string& key, const std::string& value) = 0; + /** + * Append the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, a new record is created. If the corresponding + * record exists, the given value is appended at the end of the existing value. + */ + virtual bool append(const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) = 0; + /** + * Set the value of a record. + * @note Equal to the original DB::append method except that the parameters are std::string. + */ + virtual bool append(const std::string& key, const std::string& value) = 0; + /** + * Add a number to the numeric integer value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param num the additional number. + * @param orig the origin number if no record corresponds to the key. If it is INT64MIN and + * no record corresponds, this function fails. If it is INT64MAX, the value is set as the + * additional number regardless of the current value. + * @return the result value, or kyotocabinet::INT64MIN on failure. + * @note The value is serialized as an 8-byte binary integer in big-endian order, not a decimal + * string. If existing value is not 8-byte, this function fails. + */ + virtual int64_t increment(const char* kbuf, size_t ksiz, int64_t num, int64_t orig = 0) = 0; + /** + * Add a number to the numeric integer value of a record. + * @note Equal to the original DB::increment method except that the parameter is std::string. + */ + virtual int64_t increment(const std::string& key, int64_t num, int64_t orig = 0) = 0; + /** + * Add a number to the numeric double value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param num the additional number. + * @param orig the origin number if no record corresponds to the key. If it is negative + * infinity and no record corresponds, this function fails. If it is positive infinity, the + * value is set as the additional number regardless of the current value. + * @return the result value, or Not-a-number on failure. + * @note The value is serialized as an 16-byte binary fixed-point number in big-endian order, + * not a decimal string. If existing value is not 16-byte, this function fails. + */ + virtual double increment_double(const char* kbuf, size_t ksiz, double num, + double orig = 0) = 0; + /** + * Add a number to the numeric double value of a record. + * @note Equal to the original DB::increment_double method except that the parameter is + * std::string. + */ + virtual double increment_double(const std::string& key, double num, double orig = 0) = 0; + /** + * Perform compare-and-swap. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param ovbuf the pointer to the old value region. NULL means that no record corresponds. + * @param ovsiz the size of the old value region. + * @param nvbuf the pointer to the new value region. NULL means that the record is removed. + * @param nvsiz the size of new old value region. + * @return true on success, or false on failure. + */ + virtual bool cas(const char* kbuf, size_t ksiz, + const char* ovbuf, size_t ovsiz, const char* nvbuf, size_t nvsiz) = 0; + /** + * Perform compare-and-swap. + * @note Equal to the original DB::cas method except that the parameters are std::string. + */ + virtual bool cas(const std::string& key, + const std::string& ovalue, const std::string& nvalue) = 0; + /** + * Remove a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, false is returned. + */ + virtual bool remove(const char* kbuf, size_t ksiz) = 0; + /** + * Remove a record. + * @note Equal to the original DB::remove method except that the parameter is std::string. + */ + virtual bool remove(const std::string& key) = 0; + /** + * Retrieve the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @return the pointer to the value region of the corresponding record, or NULL on failure. + * @note If no record corresponds to the key, NULL is returned. Because an additional zero + * code is appended at the end of the region of the return value, the return value can be + * treated as a C-style string. Because the region of the return value is allocated with the + * the new[] operator, it should be released with the delete[] operator when it is no longer + * in use. + */ + virtual char* get(const char* kbuf, size_t ksiz, size_t* sp) = 0; + /** + * Retrieve the value of a record. + * @note Equal to the original DB::get method except that the first parameters is the key + * string and the second parameter is a string to contain the result and the return value is + * bool for success. + */ + virtual bool get(const std::string& key, std::string* value) = 0; + /** + * Retrieve the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the buffer into which the value of the corresponding record is + * written. + * @param max the size of the buffer. + * @return the size of the value, or -1 on failure. + */ + virtual int32_t get(const char* kbuf, size_t ksiz, char* vbuf, size_t max) = 0; + /** + * Check the existence of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @return the size of the value, or -1 on failure. + */ + virtual int32_t check(const char* kbuf, size_t ksiz) = 0; + /** + * Check the existence of a record. + * @note Equal to the original DB::check method except that the parameter is std::string. + */ + virtual int32_t check(const std::string& key) = 0; + /** + * Remove all records. + * @return true on success, or false on failure. + */ + virtual bool clear() = 0; + /** + * Get the number of records. + * @return the number of records, or -1 on failure. + */ + virtual int64_t count() = 0; + /** + * Create a cursor object. + * @return the return value is the created cursor object. + * @note Because the object of the return value is allocated by the constructor, it should be + * released with the delete operator when it is no longer in use. + */ + virtual Cursor* cursor() = 0; +}; + + +/** + * Basic implementation of database. + * @note This class is an abstract class to prescribe the interface of file operations and + * provide mix-in methods. This class can be inherited but overwriting methods is forbidden. + * Before every database operation, it is necessary to call the BasicDB::open method in order to + * open a database file and connect the database object to it. To avoid data missing or + * corruption, it is important to close every database file by the BasicDB::close method when the + * database is no longer in use. It is forbidden for multible database objects in a process to + * open the same database at the same time. It is forbidden to share a database object with + * child processes. + */ +class BasicDB : public DB { + public: + class Cursor; + class Error; + class ProgressChecker; + class FileProcessor; + class Logger; + class MetaTrigger; + private: + /** The size of the IO buffer. */ + static const size_t IOBUFSIZ = 8192; + public: + /** + * Database types. + */ + enum Type { + TYPEVOID = 0x00, ///< void database + TYPEPHASH = 0x10, ///< prototype hash database + TYPEPTREE = 0x11, ///< prototype tree database + TYPESTASH = 0x18, ///< stash database + TYPECACHE = 0x20, ///< cache hash database + TYPEGRASS = 0x21, ///< cache tree database + TYPEHASH = 0x30, ///< file hash database + TYPETREE = 0x31, ///< file tree database + TYPEDIR = 0x40, ///< directory hash database + TYPEFOREST = 0x41, ///< directory tree database + TYPETEXT = 0x50, ///< plain text database + TYPEMISC = 0x80 ///< miscellaneous database + }; + /** + * Interface of cursor to indicate a record. + */ + class Cursor : public DB::Cursor { + public: + /** + * Destructor. + */ + virtual ~Cursor() { + _assert_(true); + } + /** + * Set the value of the current record. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @param step true to move the cursor to the next record, or false for no move. + * @return true on success, or false on failure. + */ + bool set_value(const char* vbuf, size_t vsiz, bool step = false) { + _assert_(vbuf && vsiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(const char* vbuf, size_t vsiz) : + vbuf_(vbuf), vsiz_(vsiz), ok_(false) {} + bool ok() const { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + ok_ = true; + *sp = vsiz_; + return vbuf_; + } + const char* vbuf_; + size_t vsiz_; + bool ok_; + }; + VisitorImpl visitor(vbuf, vsiz); + if (!accept(&visitor, true, step)) return false; + if (!visitor.ok()) return false; + return true; + } + /** + * Set the value of the current record. + * @note Equal to the original Cursor::set_value method except that the parameter is + * std::string. + */ + bool set_value_str(const std::string& value, bool step = false) { + _assert_(true); + return set_value(value.c_str(), value.size(), step); + } + /** + * Remove the current record. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, false is returned. The cursor is moved to the + * next record implicitly. + */ + bool remove() { + _assert_(true); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : ok_(false) {} + bool ok() const { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + ok_ = true; + return REMOVE; + } + bool ok_; + }; + VisitorImpl visitor; + if (!accept(&visitor, true, false)) return false; + if (!visitor.ok()) return false; + return true; + } + /** + * Get the key of the current record. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @param step true to move the cursor to the next record, or false for no move. + * @return the pointer to the key region of the current record, or NULL on failure. + * @note If the cursor is invalidated, NULL is returned. Because an additional zero + * code is appended at the end of the region of the return value, the return value can be + * treated as a C-style string. Because the region of the return value is allocated with the + * the new[] operator, it should be released with the delete[] operator when it is no longer + * in use. + */ + char* get_key(size_t* sp, bool step = false) { + _assert_(sp); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : kbuf_(NULL), ksiz_(0) {} + char* pop(size_t* sp) { + *sp = ksiz_; + return kbuf_; + } + void clear() { + delete[] kbuf_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + kbuf_ = new char[ksiz+1]; + std::memcpy(kbuf_, kbuf, ksiz); + kbuf_[ksiz] = '\0'; + ksiz_ = ksiz; + return NOP; + } + char* kbuf_; + size_t ksiz_; + }; + VisitorImpl visitor; + if (!accept(&visitor, false, step)) { + visitor.clear(); + *sp = 0; + return NULL; + } + size_t ksiz; + char* kbuf = visitor.pop(&ksiz); + if (!kbuf) { + *sp = 0; + return NULL; + } + *sp = ksiz; + return kbuf; + } + /** + * Get the key of the current record. + * @note Equal to the original Cursor::get_key method except that a parameter is a string to + * contain the result and the return value is bool for success. + */ + bool get_key(std::string* key, bool step = false) { + _assert_(key); + size_t ksiz; + char* kbuf = get_key(&ksiz, step); + if (!kbuf) return false; + key->clear(); + key->append(kbuf, ksiz); + delete[] kbuf; + return true; + } + /** + * Get the value of the current record. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @param step true to move the cursor to the next record, or false for no move. + * @return the pointer to the value region of the current record, or NULL on failure. + * @note If the cursor is invalidated, NULL is returned. Because an additional zero + * code is appended at the end of the region of the return value, the return value can be + * treated as a C-style string. Because the region of the return value is allocated with the + * the new[] operator, it should be released with the delete[] operator when it is no longer + * in use. + */ + char* get_value(size_t* sp, bool step = false) { + _assert_(sp); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : vbuf_(NULL), vsiz_(0) {} + char* pop(size_t* sp) { + *sp = vsiz_; + return vbuf_; + } + void clear() { + delete[] vbuf_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + vbuf_ = new char[vsiz+1]; + std::memcpy(vbuf_, vbuf, vsiz); + vbuf_[vsiz] = '\0'; + vsiz_ = vsiz; + return NOP; + } + char* vbuf_; + size_t vsiz_; + }; + VisitorImpl visitor; + if (!accept(&visitor, false, step)) { + visitor.clear(); + *sp = 0; + return NULL; + } + size_t vsiz; + char* vbuf = visitor.pop(&vsiz); + if (!vbuf) { + *sp = 0; + return NULL; + } + *sp = vsiz; + return vbuf; + } + /** + * Get the value of the current record. + * @note Equal to the original Cursor::get_value method except that a parameter is a string + * to contain the result and the return value is bool for success. + */ + bool get_value(std::string* value, bool step = false) { + _assert_(value); + size_t vsiz; + char* vbuf = get_value(&vsiz, step); + if (!vbuf) return false; + value->clear(); + value->append(vbuf, vsiz); + delete[] vbuf; + return true; + } + /** + * Get a pair of the key and the value of the current record. + * @param ksp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @param vbp the pointer to the variable into which the pointer to the value region is + * assigned. + * @param vsp the pointer to the variable into which the size of the value region is + * assigned. + * @param step true to move the cursor to the next record, or false for no move. + * @return the pointer to the key region, or NULL on failure. + * @note If the cursor is invalidated, NULL is returned. Because an additional zero code is + * appended at the end of each region of the key and the value, each region can be treated + * as a C-style string. The return value should be deleted explicitly by the caller with + * the detele[] operator. + */ + char* get(size_t* ksp, const char** vbp, size_t* vsp, bool step = false) { + _assert_(ksp && vbp && vsp); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : kbuf_(NULL), ksiz_(0), vbuf_(NULL), vsiz_(0) {} + char* pop(size_t* ksp, const char** vbp, size_t* vsp) { + *ksp = ksiz_; + *vbp = vbuf_; + *vsp = vsiz_; + return kbuf_; + } + void clear() { + delete[] kbuf_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + size_t rsiz = ksiz + 1 + vsiz + 1; + kbuf_ = new char[rsiz]; + std::memcpy(kbuf_, kbuf, ksiz); + kbuf_[ksiz] = '\0'; + ksiz_ = ksiz; + vbuf_ = kbuf_ + ksiz + 1; + std::memcpy(vbuf_, vbuf, vsiz); + vbuf_[vsiz] = '\0'; + vsiz_ = vsiz; + return NOP; + } + char* kbuf_; + size_t ksiz_; + char* vbuf_; + size_t vsiz_; + }; + VisitorImpl visitor; + if (!accept(&visitor, false, step)) { + visitor.clear(); + *ksp = 0; + *vbp = NULL; + *vsp = 0; + return NULL; + } + return visitor.pop(ksp, vbp, vsp); + } + /** + * Get a pair of the key and the value of the current record. + * @note Equal to the original Cursor::get method except that parameters are strings + * to contain the result and the return value is bool for success. + */ + bool get(std::string* key, std::string* value, bool step = false) { + _assert_(key && value); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(std::string* key, std::string* value) : + key_(key), value_(value), ok_(false) {} + bool ok() { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + key_->clear(); + key_->append(kbuf, ksiz); + value_->clear(); + value_->append(vbuf, vsiz); + ok_ = true; + return NOP; + } + std::string* key_; + std::string* value_; + bool ok_; + }; + VisitorImpl visitor(key, value); + if (!accept(&visitor, false, step)) return false; + return visitor.ok(); + } + /** + * Get a pair of the key and the value of the current record and remove it atomically. + * @param ksp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @param vbp the pointer to the variable into which the pointer to the value region is + * assigned. + * @param vsp the pointer to the variable into which the size of the value region is + * assigned. + * @return the pointer to the key region, or NULL on failure. + * @note If the cursor is invalidated, NULL is returned. Because an additional zero code is + * appended at the end of each region of the key and the value, each region can be treated + * as a C-style string. The return value should be deleted explicitly by the caller with + * the detele[] operator. The cursor is moved to the next record implicitly. + */ + char* seize(size_t* ksp, const char** vbp, size_t* vsp) { + _assert_(ksp && vbp && vsp); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : kbuf_(NULL), ksiz_(0), vbuf_(NULL), vsiz_(0) {} + char* pop(size_t* ksp, const char** vbp, size_t* vsp) { + *ksp = ksiz_; + *vbp = vbuf_; + *vsp = vsiz_; + return kbuf_; + } + void clear() { + delete[] kbuf_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + size_t rsiz = ksiz + 1 + vsiz + 1; + kbuf_ = new char[rsiz]; + std::memcpy(kbuf_, kbuf, ksiz); + kbuf_[ksiz] = '\0'; + ksiz_ = ksiz; + vbuf_ = kbuf_ + ksiz + 1; + std::memcpy(vbuf_, vbuf, vsiz); + vbuf_[vsiz] = '\0'; + vsiz_ = vsiz; + return REMOVE; + } + char* kbuf_; + size_t ksiz_; + char* vbuf_; + size_t vsiz_; + }; + VisitorImpl visitor; + if (!accept(&visitor, true, false)) { + visitor.clear(); + *ksp = 0; + *vbp = NULL; + *vsp = 0; + return NULL; + } + return visitor.pop(ksp, vbp, vsp); + } + /** + * Get a pair of the key and the value of the current record and remove it atomically. + * @note Equal to the original Cursor::seize method except that parameters are strings + * to contain the result and the return value is bool for success. + */ + bool seize(std::string* key, std::string* value) { + _assert_(key && value); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(std::string* key, std::string* value) : + key_(key), value_(value), ok_(false) {} + bool ok() { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + key_->clear(); + key_->append(kbuf, ksiz); + value_->clear(); + value_->append(vbuf, vsiz); + ok_ = true; + return REMOVE; + } + std::string* key_; + std::string* value_; + bool ok_; + }; + VisitorImpl visitor(key, value); + if (!accept(&visitor, true, false)) return false; + return visitor.ok(); + } + /** + * Get the database object. + * @return the database object. + */ + virtual BasicDB* db() = 0; + /** + * Get the last happened error. + * @return the last happened error. + */ + Error error() { + _assert_(true); + return db()->error(); + } + }; + /** + * Error data. + */ + class Error { + public: + /** + * Error codes. + */ + enum Code { + SUCCESS, ///< success + NOIMPL, ///< not implemented + INVALID, ///< invalid operation + NOREPOS, ///< no repository + NOPERM, ///< no permission + BROKEN, ///< broken file + DUPREC, ///< record duplication + NOREC, ///< no record + LOGIC, ///< logical inconsistency + SYSTEM, ///< system error + MISC = 15 ///< miscellaneous error + }; + /** + * Default constructor. + */ + explicit Error() : code_(SUCCESS), message_("no error") { + _assert_(true); + } + /** + * Copy constructor. + * @param src the source object. + */ + Error(const Error& src) : code_(src.code_), message_(src.message_) { + _assert_(true); + } + /** + * Constructor. + * @param code an error code. + * @param message a supplement message. + */ + explicit Error(Code code, const char* message) : code_(code), message_(message) { + _assert_(message); + } + /** + * Destructor. + */ + ~Error() { + _assert_(true); + } + /** + * Set the error information. + * @param code an error code. + * @param message a supplement message. + */ + void set(Code code, const char* message) { + _assert_(message); + code_ = code; + message_ = message; + } + /** + * Get the error code. + * @return the error code. + */ + Code code() const { + _assert_(true); + return code_; + } + /** + * Get the readable string of the code. + * @return the readable string of the code. + */ + const char* name() const { + _assert_(true); + return codename(code_); + } + /** + * Get the supplement message. + * @return the supplement message. + */ + const char* message() const { + _assert_(true); + return message_; + } + /** + * Get the readable string of an error code. + * @param code the error code. + * @return the readable string of the error code. + */ + static const char* codename(Code code) { + _assert_(true); + switch (code) { + case SUCCESS: return "success"; + case NOIMPL: return "not implemented"; + case INVALID: return "invalid operation"; + case NOREPOS: return "no repository"; + case NOPERM: return "no permission"; + case BROKEN: return "broken file"; + case DUPREC: return "record duplication"; + case NOREC: return "no record"; + case LOGIC: return "logical inconsistency"; + case SYSTEM: return "system error"; + default: break; + } + return "miscellaneous error"; + } + /** + * Assignment operator from the self type. + * @param right the right operand. + * @return the reference to itself. + */ + Error& operator =(const Error& right) { + _assert_(true); + if (&right == this) return *this; + code_ = right.code_; + message_ = right.message_; + return *this; + } + /** + * Cast operator to integer. + * @return the error code. + */ + operator int32_t() const { + return code_; + } + private: + /** The error code. */ + Code code_; + /** The supplement message. */ + const char* message_; + }; + /** + * Interface to check progress status of long process. + */ + class ProgressChecker { + public: + /** + * Destructor. + */ + virtual ~ProgressChecker() { + _assert_(true); + } + /** + * Check the progress status. + * @param name the name of the process. + * @param message a supplement message. + * @param curcnt the count of the current step of the progress, or -1 if not applicable. + * @param allcnt the estimation count of all steps of the progress, or -1 if not applicable. + * @return true to continue the process, or false to stop the process. + */ + virtual bool check(const char* name, const char* message, + int64_t curcnt, int64_t allcnt) = 0; + }; + /** + * Interface to process the database file. + */ + class FileProcessor { + public: + /** + * Destructor. + */ + virtual ~FileProcessor() { + _assert_(true); + } + /** + * Process the database file. + * @param path the path of the database file. + * @param count the number of records. A negative value means omission. + * @param size the size of the available region. A negative value means omission. + * @return true on success, or false on failure. + */ + virtual bool process(const std::string& path, int64_t count, int64_t size) = 0; + }; + /** + * Interface to log internal information and errors. + */ + class Logger { + public: + /** + * Event kinds. + */ + enum Kind { + DEBUG = 1 << 0, ///< debugging + INFO = 1 << 1, ///< normal information + WARN = 1 << 2, ///< warning + ERROR = 1 << 3 ///< error + }; + /** + * Destructor. + */ + virtual ~Logger() { + _assert_(true); + } + /** + * Process a log message. + * @param file the file name of the program source code. + * @param line the line number of the program source code. + * @param func the function name of the program source code. + * @param kind the kind of the event. Logger::DEBUG for debugging, Logger::INFO for normal + * information, Logger::WARN for warning, and Logger::ERROR for fatal error. + * @param message the supplement message. + */ + virtual void log(const char* file, int32_t line, const char* func, Kind kind, + const char* message) = 0; + }; + /** + * Interface to trigger meta database operations. + */ + class MetaTrigger { + public: + /** + * Event kinds. + */ + enum Kind { + OPEN, ///< opening + CLOSE, ///< closing + CLEAR, ///< clearing + ITERATE, ///< iteration + SYNCHRONIZE, ///< synchronization + OCCUPY, ///< occupation + BEGINTRAN, ///< beginning transaction + COMMITTRAN, ///< committing transaction + ABORTTRAN, ///< aborting transaction + MISC = 15 ///< miscellaneous operation + }; + /** + * Destructor. + */ + virtual ~MetaTrigger() { + _assert_(true); + } + /** + * Trigger a meta database operation. + * @param kind the kind of the event. MetaTrigger::OPEN for opening, MetaTrigger::CLOSE for + * closing, MetaTrigger::CLEAR for clearing, MetaTrigger::ITERATE for iteration, + * MetaTrigger::SYNCHRONIZE for synchronization, MetaTrigger::OCCUPY for occupation, + * MetaTrigger::BEGINTRAN for beginning transaction, MetaTrigger::COMMITTRAN for committing + * transaction, MetaTrigger::ABORTTRAN for aborting transaction, and MetaTrigger::MISC for + * miscellaneous operations. + * @param message the supplement message. + */ + virtual void trigger(Kind kind, const char* message) = 0; + }; + /** + * Open modes. + */ + enum OpenMode { + OREADER = 1 << 0, ///< open as a reader + OWRITER = 1 << 1, ///< open as a writer + OCREATE = 1 << 2, ///< writer creating + OTRUNCATE = 1 << 3, ///< writer truncating + OAUTOTRAN = 1 << 4, ///< auto transaction + OAUTOSYNC = 1 << 5, ///< auto synchronization + ONOLOCK = 1 << 6, ///< open without locking + OTRYLOCK = 1 << 7, ///< lock without blocking + ONOREPAIR = 1 << 8 ///< open without auto repair + }; + /** + * Destructor. + * @note If the database is not closed, it is closed implicitly. + */ + virtual ~BasicDB() { + _assert_(true); + } + /** + * Get the last happened error. + * @return the last happened error. + */ + virtual Error error() const = 0; + /** + * Set the error information. + * @param file the file name of the program source code. + * @param line the line number of the program source code. + * @param func the function name of the program source code. + * @param code an error code. + * @param message a supplement message. + */ + virtual void set_error(const char* file, int32_t line, const char* func, + Error::Code code, const char* message) = 0; + /** + * Open a database file. + * @param path the path of a database file. + * @param mode the connection mode. BasicDB::OWRITER as a writer, BasicDB::OREADER as a + * reader. The following may be added to the writer mode by bitwise-or: BasicDB::OCREATE, + * which means it creates a new database if the file does not exist, BasicDB::OTRUNCATE, which + * means it creates a new database regardless if the file exists, BasicDB::OAUTOTRAN, which + * means each updating operation is performed in implicit transaction, BasicDB::OAUTOSYNC, + * which means each updating operation is followed by implicit synchronization with the file + * system. The following may be added to both of the reader mode and the writer mode by + * bitwise-or: BasicDB::ONOLOCK, which means it opens the database file without file locking, + * BasicDB::OTRYLOCK, which means locking is performed without blocking, File::ONOREPAIR, which + * means the database file is not repaired implicitly even if file destruction is detected. + * @return true on success, or false on failure. + * @note Every opened database must be closed by the BasicDB::close method when it is no longer + * in use. It is not allowed for two or more database objects in the same process to keep + * their connections to the same database file at the same time. + */ + virtual bool open(const std::string& path, uint32_t mode = OWRITER | OCREATE) = 0; + /** + * Close the database file. + * @return true on success, or false on failure. + */ + virtual bool close() = 0; + /** + * Accept a visitor to multiple records at once. + * @param keys specifies a string vector of the keys. + * @param visitor a visitor object. + * @param writable true for writable operation, or false for read-only operation. + * @return true on success, or false on failure. + * @note The operations for specified records are performed atomically and other threads + * accessing the same records are blocked. To avoid deadlock, any explicit database operation + * must not be performed in this function. + */ + virtual bool accept_bulk(const std::vector<std::string>& keys, Visitor* visitor, + bool writable = true) = 0; + /** + * Iterate to accept a visitor for each record. + * @param visitor a visitor object. + * @param writable true for writable operation, or false for read-only operation. + * @param checker a progress checker object. If it is NULL, no checking is performed. + * @return true on success, or false on failure. + * @note The whole iteration is performed atomically and other threads are blocked. To avoid + * deadlock, any explicit database operation must not be performed in this function. + */ + virtual bool iterate(Visitor *visitor, bool writable = true, + ProgressChecker* checker = NULL) = 0; + /** + * Scan each record in parallel. + * @param visitor a visitor object. + * @param thnum the number of worker threads. + * @param checker a progress checker object. If it is NULL, no checking is performed. + * @return true on success, or false on failure. + * @note This function is for reading records and not for updating ones. The return value of + * the visitor is just ignored. To avoid deadlock, any explicit database operation must not + * be performed in this function. + */ + virtual bool scan_parallel(Visitor *visitor, size_t thnum, + ProgressChecker* checker = NULL) = 0; + /** + * Synchronize updated contents with the file and the device. + * @param hard true for physical synchronization with the device, or false for logical + * synchronization with the file system. + * @param proc a postprocessor object. If it is NULL, no postprocessing is performed. + * @param checker a progress checker object. If it is NULL, no checking is performed. + * @return true on success, or false on failure. + * @note The operation of the postprocessor is performed atomically and other threads accessing + * the same record are blocked. To avoid deadlock, any explicit database operation must not + * be performed in this function. + */ + virtual bool synchronize(bool hard = false, FileProcessor* proc = NULL, + ProgressChecker* checker = NULL) = 0; + /** + * Occupy database by locking and do something meanwhile. + * @param writable true to use writer lock, or false to use reader lock. + * @param proc a processor object. If it is NULL, no processing is performed. + * @return true on success, or false on failure. + * @note The operation of the processor is performed atomically and other threads accessing + * the same record are blocked. To avoid deadlock, any explicit database operation must not + * be performed in this function. + */ + virtual bool occupy(bool writable = true, FileProcessor* proc = NULL) = 0; + /** + * Create a copy of the database file. + * @param dest the path of the destination file. + * @param checker a progress checker object. If it is NULL, no checking is performed. + * @return true on success, or false on failure. + */ + bool copy(const std::string& dest, ProgressChecker* checker = NULL) { + _assert_(true); + class FileProcessorImpl : public FileProcessor { + public: + explicit FileProcessorImpl(const std::string& dest, ProgressChecker* checker, + BasicDB* db) : + dest_(dest), checker_(checker), db_(db) {} + private: + bool process(const std::string& path, int64_t count, int64_t size) { + File::Status sbuf; + if (!File::status(path, &sbuf)) return false; + if (sbuf.isdir) { + if (!File::make_directory(dest_)) return false; + bool err = false; + DirStream dir; + if (dir.open(path)) { + if (checker_ && !checker_->check("copy", "beginning", 0, -1)) { + db_->set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + } + std::string name; + int64_t curcnt = 0; + while (!err && dir.read(&name)) { + const std::string& spath = path + File::PATHCHR + name; + const std::string& dpath = dest_ + File::PATHCHR + name; + int64_t dsiz; + char* dbuf = File::read_file(spath, &dsiz); + if (dbuf) { + if (!File::write_file(dpath, dbuf, dsiz)) err = true; + delete[] dbuf; + } else { + err = true; + } + curcnt++; + if (checker_ && !checker_->check("copy", "processing", curcnt, -1)) { + db_->set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + break; + } + } + if (checker_ && !checker_->check("copy", "ending", -1, -1)) { + db_->set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + } + if (!dir.close()) err = true; + } else { + err = true; + } + return !err; + } + std::ofstream ofs; + ofs.open(dest_.c_str(), + std::ios_base::out | std::ios_base::binary | std::ios_base::trunc); + if (!ofs) return false; + bool err = false; + std::ifstream ifs; + ifs.open(path.c_str(), std::ios_base::in | std::ios_base::binary); + if (checker_ && !checker_->check("copy", "beginning", 0, size)) { + db_->set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + } + if (ifs) { + char buf[IOBUFSIZ]; + int64_t curcnt = 0; + while (!err && !ifs.eof()) { + size_t n = ifs.read(buf, sizeof(buf)).gcount(); + if (n > 0) { + ofs.write(buf, n); + if (!ofs) { + err = true; + break; + } + } + curcnt += n; + if (checker_ && !checker_->check("copy", "processing", curcnt, size)) { + db_->set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + break; + } + } + ifs.close(); + if (ifs.bad()) err = true; + } else { + err = true; + } + if (checker_ && !checker_->check("copy", "ending", -1, size)) { + db_->set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + } + ofs.close(); + if (!ofs) err = true; + return !err; + } + const std::string& dest_; + ProgressChecker* checker_; + BasicDB* db_; + }; + FileProcessorImpl proc(dest, checker, this); + return synchronize(false, &proc, checker); + } + /** + * Begin transaction. + * @param hard true for physical synchronization with the device, or false for logical + * synchronization with the file system. + * @return true on success, or false on failure. + */ + virtual bool begin_transaction(bool hard = false) = 0; + /** + * Try to begin transaction. + * @param hard true for physical synchronization with the device, or false for logical + * synchronization with the file system. + * @return true on success, or false on failure. + */ + virtual bool begin_transaction_try(bool hard = false) = 0; + /** + * End transaction. + * @param commit true to commit the transaction, or false to abort the transaction. + * @return true on success, or false on failure. + */ + virtual bool end_transaction(bool commit = true) = 0; + /** + * Get the size of the database file. + * @return the size of the database file in bytes, or -1 on failure. + */ + virtual int64_t size() = 0; + /** + * Get the path of the database file. + * @return the path of the database file, or an empty string on failure. + */ + virtual std::string path() = 0; + /** + * Get the miscellaneous status information. + * @param strmap a string map to contain the result. + * @return true on success, or false on failure. + */ + virtual bool status(std::map<std::string, std::string>* strmap) = 0; + /** + * Set the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, a new record is created. If the corresponding + * record exists, the value is overwritten. + */ + bool set(const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(const char* vbuf, size_t vsiz) : vbuf_(vbuf), vsiz_(vsiz) {} + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + *sp = vsiz_; + return vbuf_; + } + const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) { + *sp = vsiz_; + return vbuf_; + } + const char* vbuf_; + size_t vsiz_; + }; + VisitorImpl visitor(vbuf, vsiz); + if (!accept(kbuf, ksiz, &visitor, true)) return false; + return true; + } + /** + * Set the value of a record. + * @note Equal to the original DB::set method except that the parameters are std::string. + */ + bool set(const std::string& key, const std::string& value) { + _assert_(true); + return set(key.c_str(), key.size(), value.c_str(), value.size()); + } + /** + * Add a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, a new record is created. If the corresponding + * record exists, the record is not modified and false is returned. + */ + bool add(const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(const char* vbuf, size_t vsiz) : + vbuf_(vbuf), vsiz_(vsiz), ok_(false) {} + bool ok() const { + return ok_; + } + private: + const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) { + ok_ = true; + *sp = vsiz_; + return vbuf_; + } + const char* vbuf_; + size_t vsiz_; + bool ok_; + }; + VisitorImpl visitor(vbuf, vsiz); + if (!accept(kbuf, ksiz, &visitor, true)) return false; + if (!visitor.ok()) { + set_error(_KCCODELINE_, Error::DUPREC, "record duplication"); + return false; + } + return true; + } + /** + * Set the value of a record. + * @note Equal to the original DB::add method except that the parameters are std::string. + */ + bool add(const std::string& key, const std::string& value) { + _assert_(true); + return add(key.c_str(), key.size(), value.c_str(), value.size()); + } + /** + * Replace the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, no new record is created and false is returned. + * If the corresponding record exists, the value is modified. + */ + bool replace(const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(const char* vbuf, size_t vsiz) : + vbuf_(vbuf), vsiz_(vsiz), ok_(false) {} + bool ok() const { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + ok_ = true; + *sp = vsiz_; + return vbuf_; + } + const char* vbuf_; + size_t vsiz_; + bool ok_; + }; + VisitorImpl visitor(vbuf, vsiz); + if (!accept(kbuf, ksiz, &visitor, true)) return false; + if (!visitor.ok()) { + set_error(_KCCODELINE_, Error::NOREC, "no record"); + return false; + } + return true; + } + /** + * Replace the value of a record. + * @note Equal to the original DB::replace method except that the parameters are std::string. + */ + bool replace(const std::string& key, const std::string& value) { + _assert_(true); + return replace(key.c_str(), key.size(), value.c_str(), value.size()); + } + /** + * Append the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the value region. + * @param vsiz the size of the value region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, a new record is created. If the corresponding + * record exists, the given value is appended at the end of the existing value. + */ + bool append(const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(const char* vbuf, size_t vsiz) : + vbuf_(vbuf), vsiz_(vsiz), nbuf_(NULL) {} + ~VisitorImpl() { + if (nbuf_) delete[] nbuf_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + size_t nsiz = vsiz + vsiz_; + nbuf_ = new char[nsiz]; + std::memcpy(nbuf_, vbuf, vsiz); + std::memcpy(nbuf_ + vsiz, vbuf_, vsiz_); + *sp = nsiz; + return nbuf_; + } + const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) { + *sp = vsiz_; + return vbuf_; + } + const char* vbuf_; + size_t vsiz_; + char* nbuf_; + }; + VisitorImpl visitor(vbuf, vsiz); + if (!accept(kbuf, ksiz, &visitor, true)) return false; + return true; + } + /** + * Set the value of a record. + * @note Equal to the original DB::append method except that the parameters are std::string. + */ + bool append(const std::string& key, const std::string& value) { + _assert_(true); + return append(key.c_str(), key.size(), value.c_str(), value.size()); + } + /** + * Add a number to the numeric value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param num the additional number. + * @param orig the origin number if no record corresponds to the key. If it is INT64MIN and + * no record corresponds, this function fails. If it is INT64MAX, the value is set as the + * additional number regardless of the current value. + * @return the result value, or kyotocabinet::INT64MIN on failure. + * @note The value is serialized as an 8-byte binary integer in big-endian order, not a decimal + * string. If existing value is not 8-byte, this function fails. + */ + int64_t increment(const char* kbuf, size_t ksiz, int64_t num, int64_t orig = 0) { + _assert_(kbuf && ksiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(int64_t num, int64_t orig) : num_(num), orig_(orig), big_(0) {} + int64_t num() { + return num_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + if (vsiz != sizeof(num_)) { + num_ = INT64MIN; + return NOP; + } + int64_t onum; + if (orig_ == INT64MAX) { + onum = 0; + } else { + std::memcpy(&onum, vbuf, vsiz); + onum = ntoh64(onum); + if (num_ == 0) { + num_ = onum; + return NOP; + } + } + num_ += onum; + big_ = hton64(num_); + *sp = sizeof(big_); + return (const char*)&big_; + } + const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) { + if (orig_ == INT64MIN) { + num_ = INT64MIN; + return NOP; + } + if (orig_ != INT64MAX) num_ += orig_; + big_ = hton64(num_); + *sp = sizeof(big_); + return (const char*)&big_; + } + int64_t num_; + int64_t orig_; + uint64_t big_; + }; + VisitorImpl visitor(num, orig); + if (!accept(kbuf, ksiz, &visitor, num != 0 || orig != INT64MIN)) return INT64MIN; + num = visitor.num(); + if (num == INT64MIN) { + set_error(_KCCODELINE_, Error::LOGIC, "logical inconsistency"); + return num; + } + return num; + } + /** + * Add a number to the numeric value of a record. + * @note Equal to the original DB::increment method except that the parameter is std::string. + */ + int64_t increment(const std::string& key, int64_t num, int64_t orig = 0) { + _assert_(true); + return increment(key.c_str(), key.size(), num, orig); + } + /** + * Add a number to the numeric double value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param num the additional number. + * @param orig the origin number if no record corresponds to the key. If it is negative + * infinity and no record corresponds, this function fails. If it is positive infinity, the + * value is set as the additional number regardless of the current value. + * @return the result value, or Not-a-number on failure. + * @note The value is serialized as an 16-byte binary fixed-point number in big-endian order, + * not a decimal string. If existing value is not 16-byte, this function fails. + */ + double increment_double(const char* kbuf, size_t ksiz, double num, double orig = 0) { + _assert_(kbuf && ksiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(double num, double orig) : + DECUNIT(1000000000000000LL), num_(num), orig_(orig), buf_() {} + double num() { + return num_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + if (vsiz != sizeof(buf_)) { + num_ = nan(); + return NOP; + } + int64_t linteg, lfract; + if (chkinf(orig_) && orig_ >= 0) { + linteg = 0; + lfract = 0; + } else { + std::memcpy(&linteg, vbuf, sizeof(linteg)); + linteg = ntoh64(linteg); + std::memcpy(&lfract, vbuf + sizeof(linteg), sizeof(lfract)); + lfract = ntoh64(lfract); + } + if (lfract == INT64MIN && linteg == INT64MIN) { + num_ = nan(); + return NOP; + } else if (linteg == INT64MAX) { + num_ = HUGE_VAL; + return NOP; + } else if (linteg == INT64MIN) { + num_ = -HUGE_VAL; + return NOP; + } + if (num_ == 0.0 && !(chkinf(orig_) && orig_ >= 0)) { + num_ = linteg + (double)lfract / DECUNIT; + return NOP; + } + long double dinteg; + long double dfract = std::modfl(num_, &dinteg); + if (chknan(dinteg)) { + linteg = INT64MIN; + lfract = INT64MIN; + num_ = nan(); + } else if (chkinf(dinteg)) { + linteg = dinteg > 0 ? INT64MAX : INT64MIN; + lfract = 0; + num_ = dinteg; + } else { + linteg += (int64_t)dinteg; + lfract += (int64_t)(dfract * DECUNIT); + if (lfract >= DECUNIT) { + linteg += 1; + lfract -= DECUNIT; + } + num_ = linteg + (double)lfract / DECUNIT; + } + linteg = hton64(linteg); + std::memcpy(buf_, &linteg, sizeof(linteg)); + lfract = hton64(lfract); + std::memcpy(buf_ + sizeof(linteg), &lfract, sizeof(lfract)); + *sp = sizeof(buf_); + return buf_; + } + const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) { + if (chknan(orig_) || (chkinf(orig_) && orig_ < 0)) { + num_ = nan(); + return NOP; + } + if (!chkinf(orig_)) num_ += orig_; + long double dinteg; + long double dfract = std::modfl(num_, &dinteg); + int64_t linteg, lfract; + if (chknan(dinteg)) { + linteg = INT64MIN; + lfract = INT64MIN; + } else if (chkinf(dinteg)) { + linteg = dinteg > 0 ? INT64MAX : INT64MIN; + lfract = 0; + } else { + linteg = (int64_t)dinteg; + lfract = (int64_t)(dfract * DECUNIT); + } + linteg = hton64(linteg); + std::memcpy(buf_, &linteg, sizeof(linteg)); + lfract = hton64(lfract); + std::memcpy(buf_ + sizeof(linteg), &lfract, sizeof(lfract)); + *sp = sizeof(buf_); + return buf_; + } + const int64_t DECUNIT; + double num_; + double orig_; + char buf_[sizeof(int64_t)*2]; + }; + VisitorImpl visitor(num, orig); + if (!accept(kbuf, ksiz, &visitor, true)) return nan(); + num = visitor.num(); + if (chknan(num)) { + set_error(_KCCODELINE_, Error::LOGIC, "logical inconsistency"); + return nan(); + } + return num; + } + /** + * Add a number to the numeric double value of a record. + * @note Equal to the original DB::increment_double method except that the parameter is + * std::string. + */ + double increment_double(const std::string& key, double num, double orig) { + _assert_(true); + return increment_double(key.c_str(), key.size(), num, orig); + } + /** + * Perform compare-and-swap. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param ovbuf the pointer to the old value region. NULL means that no record corresponds. + * @param ovsiz the size of the old value region. + * @param nvbuf the pointer to the new value region. NULL means that the record is removed. + * @param nvsiz the size of new old value region. + * @return true on success, or false on failure. + */ + bool cas(const char* kbuf, size_t ksiz, + const char* ovbuf, size_t ovsiz, const char* nvbuf, size_t nvsiz) { + _assert_(kbuf && ksiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(const char* ovbuf, size_t ovsiz, const char* nvbuf, size_t nvsiz) : + ovbuf_(ovbuf), ovsiz_(ovsiz), nvbuf_(nvbuf), nvsiz_(nvsiz), ok_(false) {} + bool ok() const { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + if (!ovbuf_ || vsiz != ovsiz_ || std::memcmp(vbuf, ovbuf_, vsiz)) return NOP; + ok_ = true; + if (!nvbuf_) return REMOVE; + *sp = nvsiz_; + return nvbuf_; + } + const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) { + if (ovbuf_) return NOP; + ok_ = true; + if (!nvbuf_) return NOP; + *sp = nvsiz_; + return nvbuf_; + } + const char* ovbuf_; + size_t ovsiz_; + const char* nvbuf_; + size_t nvsiz_; + bool ok_; + }; + VisitorImpl visitor(ovbuf, ovsiz, nvbuf, nvsiz); + if (!accept(kbuf, ksiz, &visitor, true)) return false; + if (!visitor.ok()) { + set_error(_KCCODELINE_, Error::LOGIC, "status conflict"); + return false; + } + return true; + } + /** + * Perform compare-and-swap. + * @note Equal to the original DB::cas method except that the parameters are std::string. + */ + bool cas(const std::string& key, + const std::string& ovalue, const std::string& nvalue) { + _assert_(true); + return cas(key.c_str(), key.size(), + ovalue.c_str(), ovalue.size(), nvalue.c_str(), nvalue.size()); + } + /** + * Remove a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @return true on success, or false on failure. + * @note If no record corresponds to the key, false is returned. + */ + bool remove(const char* kbuf, size_t ksiz) { + _assert_(kbuf && ksiz <= MEMMAXSIZ); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : ok_(false) {} + bool ok() const { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + ok_ = true; + return REMOVE; + } + bool ok_; + }; + VisitorImpl visitor; + if (!accept(kbuf, ksiz, &visitor, true)) return false; + if (!visitor.ok()) { + set_error(_KCCODELINE_, Error::NOREC, "no record"); + return false; + } + return true; + } + /** + * Remove a record. + * @note Equal to the original DB::remove method except that the parameter is std::string. + */ + bool remove(const std::string& key) { + _assert_(true); + return remove(key.c_str(), key.size()); + } + /** + * Retrieve the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @return the pointer to the value region of the corresponding record, or NULL on failure. + * @note If no record corresponds to the key, NULL is returned. Because an additional zero + * code is appended at the end of the region of the return value, the return value can be + * treated as a C-style string. Because the region of the return value is allocated with the + * the new[] operator, it should be released with the delete[] operator when it is no longer + * in use. + */ + char* get(const char* kbuf, size_t ksiz, size_t* sp) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && sp); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : vbuf_(NULL), vsiz_(0) {} + char* pop(size_t* sp) { + *sp = vsiz_; + return vbuf_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + vbuf_ = new char[vsiz+1]; + std::memcpy(vbuf_, vbuf, vsiz); + vbuf_[vsiz] = '\0'; + vsiz_ = vsiz; + return NOP; + } + char* vbuf_; + size_t vsiz_; + }; + VisitorImpl visitor; + if (!accept(kbuf, ksiz, &visitor, false)) { + *sp = 0; + return NULL; + } + size_t vsiz; + char* vbuf = visitor.pop(&vsiz); + if (!vbuf) { + set_error(_KCCODELINE_, Error::NOREC, "no record"); + *sp = 0; + return NULL; + } + *sp = vsiz; + return vbuf; + } + /** + * Retrieve the value of a record. + * @note Equal to the original DB::get method except that the first parameters is the key + * string and the second parameter is a string to contain the result and the return value is + * bool for success. + */ + bool get(const std::string& key, std::string* value) { + _assert_(value); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(std::string* value) : value_(value), ok_(false) {} + bool ok() { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + value_->clear(); + value_->append(vbuf, vsiz); + ok_ = true; + return NOP; + } + std::string* value_; + bool ok_; + }; + VisitorImpl visitor(value); + if (!accept(key.data(), key.size(), &visitor, false)) return false; + if (!visitor.ok()) { + set_error(_KCCODELINE_, Error::NOREC, "no record"); + return false; + } + return true; + } + /** + * Retrieve the value of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param vbuf the pointer to the buffer into which the value of the corresponding record is + * written. + * @param max the size of the buffer. + * @return the size of the value, or -1 on failure. + */ + int32_t get(const char* kbuf, size_t ksiz, char* vbuf, size_t max) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && vbuf); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(char* vbuf, size_t max) : vbuf_(vbuf), max_(max), vsiz_(-1) {} + int32_t vsiz() { + return vsiz_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + vsiz_ = vsiz; + size_t max = vsiz < max_ ? vsiz : max_; + std::memcpy(vbuf_, vbuf, max); + return NOP; + } + char* vbuf_; + size_t max_; + int32_t vsiz_; + }; + VisitorImpl visitor(vbuf, max); + if (!accept(kbuf, ksiz, &visitor, false)) return -1; + int32_t vsiz = visitor.vsiz(); + if (vsiz < 0) { + set_error(_KCCODELINE_, Error::NOREC, "no record"); + return -1; + } + return vsiz; + } + /** + * Check the existence of a record. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @return the size of the value, or -1 on failure. + */ + int32_t check(const char* kbuf, size_t ksiz) { + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : vsiz_(-1) {} + int32_t vsiz() { + return vsiz_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + vsiz_ = vsiz; + return NOP; + } + size_t vsiz_; + }; + VisitorImpl visitor; + if (!accept(kbuf, ksiz, &visitor, false)) return -1; + int32_t vsiz = visitor.vsiz(); + if (vsiz < 0) { + set_error(_KCCODELINE_, Error::NOREC, "no record"); + return -1; + } + return vsiz; + } + /** + * Check the existence of a record. + * @note Equal to the original DB::check method except that the parameter is std::string. + */ + int32_t check(const std::string& key) { + return check(key.data(), key.size()); + } + /** + * Retrieve the value of a record and remove it atomically. + * @param kbuf the pointer to the key region. + * @param ksiz the size of the key region. + * @param sp the pointer to the variable into which the size of the region of the return + * value is assigned. + * @return the pointer to the value region of the corresponding record, or NULL on failure. + * @note If no record corresponds to the key, NULL is returned. Because an additional zero + * code is appended at the end of the region of the return value, the return value can be + * treated as a C-style string. Because the region of the return value is allocated with the + * the new[] operator, it should be released with the delete[] operator when it is no longer + * in use. + */ + char* seize(const char* kbuf, size_t ksiz, size_t* sp) { + _assert_(kbuf && ksiz <= MEMMAXSIZ && sp); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : vbuf_(NULL), vsiz_(0) {} + char* pop(size_t* sp) { + *sp = vsiz_; + return vbuf_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + vbuf_ = new char[vsiz+1]; + std::memcpy(vbuf_, vbuf, vsiz); + vbuf_[vsiz] = '\0'; + vsiz_ = vsiz; + return REMOVE; + } + char* vbuf_; + size_t vsiz_; + }; + VisitorImpl visitor; + if (!accept(kbuf, ksiz, &visitor, true)) { + *sp = 0; + return NULL; + } + size_t vsiz; + char* vbuf = visitor.pop(&vsiz); + if (!vbuf) { + set_error(_KCCODELINE_, Error::NOREC, "no record"); + *sp = 0; + return NULL; + } + *sp = vsiz; + return vbuf; + } + /** + * Retrieve the value of a record and remove it atomically. + * @note Equal to the original DB::seize method except that the first parameters is the key + * string and the second parameter is a string to contain the result and the return value is + * bool for success. + */ + bool seize(const std::string& key, std::string* value) { + _assert_(value); + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(std::string* value) : value_(value), ok_(false) {} + bool ok() { + return ok_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + value_->clear(); + value_->append(vbuf, vsiz); + ok_ = true; + return REMOVE; + } + std::string* value_; + bool ok_; + }; + VisitorImpl visitor(value); + if (!accept(key.data(), key.size(), &visitor, true)) return false; + if (!visitor.ok()) { + set_error(_KCCODELINE_, Error::NOREC, "no record"); + return false; + } + return true; + } + /** + * Store records at once. + * @param recs the records to store. + * @param atomic true to perform all operations atomically, or false for non-atomic operations. + * @return the number of stored records, or -1 on failure. + */ + int64_t set_bulk(const std::map<std::string, std::string>& recs, bool atomic = true) { + _assert_(true); + if (atomic) { + std::vector<std::string> keys; + keys.reserve(recs.size()); + std::map<std::string, std::string>::const_iterator rit = recs.begin(); + std::map<std::string, std::string>::const_iterator ritend = recs.end(); + while (rit != ritend) { + keys.push_back(rit->first); + ++rit; + } + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(const std::map<std::string, std::string>& recs) : recs_(recs) {} + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + std::map<std::string, std::string>::const_iterator rit = + recs_.find(std::string(kbuf, ksiz)); + if (rit == recs_.end()) return NOP; + *sp = rit->second.size(); + return rit->second.data(); + } + const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) { + std::map<std::string, std::string>::const_iterator rit = + recs_.find(std::string(kbuf, ksiz)); + if (rit == recs_.end()) return NOP; + *sp = rit->second.size(); + return rit->second.data(); + } + const std::map<std::string, std::string>& recs_; + }; + VisitorImpl visitor(recs); + if (!accept_bulk(keys, &visitor, true)) return -1; + return keys.size(); + } + std::map<std::string, std::string>::const_iterator rit = recs.begin(); + std::map<std::string, std::string>::const_iterator ritend = recs.end(); + while (rit != ritend) { + if (!set(rit->first.data(), rit->first.size(), rit->second.data(), rit->second.size())) + return -1; + ++rit; + } + return recs.size(); + } + /** + * Remove records at once. + * @param keys the keys of the records to remove. + * @param atomic true to perform all operations atomically, or false for non-atomic operations. + * @return the number of removed records, or -1 on failure. + */ + int64_t remove_bulk(const std::vector<std::string>& keys, bool atomic = true) { + _assert_(true); + if (atomic) { + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl() : cnt_(0) {} + int64_t cnt() const { + return cnt_; + } + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + cnt_++; + return REMOVE; + } + int64_t cnt_; + }; + VisitorImpl visitor; + if (!accept_bulk(keys, &visitor, true)) return -1; + return visitor.cnt(); + } + int64_t cnt = 0; + std::vector<std::string>::const_iterator kit = keys.begin(); + std::vector<std::string>::const_iterator kitend = keys.end(); + while (kit != kitend) { + if (remove(kit->data(), kit->size())) { + cnt++; + } else if (error() != Error::NOREC) { + return -1; + } + ++kit; + } + return cnt; + } + /** + * Retrieve records at once. + * @param keys the keys of the records to retrieve. + * @param recs a string map to contain the retrieved records. + * @param atomic true to perform all operations atomically, or false for non-atomic operations. + * @return the number of retrieved records, or -1 on failure. + */ + int64_t get_bulk(const std::vector<std::string>& keys, + std::map<std::string, std::string>* recs, bool atomic = true) { + _assert_(recs); + if (atomic) { + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(std::map<std::string, std::string>* recs) : recs_(recs) {} + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + (*recs_)[std::string(kbuf, ksiz)] = std::string(vbuf, vsiz); + return NOP; + } + std::map<std::string, std::string>* recs_; + }; + VisitorImpl visitor(recs); + if (!accept_bulk(keys, &visitor, false)) return -1; + return recs->size(); + } + std::vector<std::string>::const_iterator kit = keys.begin(); + std::vector<std::string>::const_iterator kitend = keys.end(); + while (kit != kitend) { + size_t vsiz; + const char* vbuf = get(kit->data(), kit->size(), &vsiz); + if (vbuf) { + (*recs)[*kit] = std::string(vbuf, vsiz); + delete[] vbuf; + } else if (error() != Error::NOREC) { + return -1; + } + ++kit; + } + return recs->size(); + } + /** + * Dump records into a data stream. + * @param dest the destination stream. + * @param checker a progress checker object. If it is NULL, no checking is performed. + * @return true on success, or false on failure. + */ + bool dump_snapshot(std::ostream* dest, ProgressChecker* checker = NULL) { + _assert_(dest); + if (dest->fail()) { + set_error(_KCCODELINE_, Error::INVALID, "invalid stream"); + return false; + } + class VisitorImpl : public Visitor { + public: + explicit VisitorImpl(std::ostream* dest) : dest_(dest), stack_() {} + private: + const char* visit_full(const char* kbuf, size_t ksiz, + const char* vbuf, size_t vsiz, size_t* sp) { + char* wp = stack_; + *(wp++) = 0x00; + wp += writevarnum(wp, ksiz); + wp += writevarnum(wp, vsiz); + dest_->write(stack_, wp - stack_); + dest_->write(kbuf, ksiz); + dest_->write(vbuf, vsiz); + return NOP; + } + std::ostream* dest_; + char stack_[NUMBUFSIZ*2]; + }; + VisitorImpl visitor(dest); + bool err = false; + dest->write(KCDBSSMAGICDATA, sizeof(KCDBSSMAGICDATA)); + if (iterate(&visitor, false, checker)) { + unsigned char c = 0xff; + dest->write((char*)&c, 1); + if (dest->fail()) { + set_error(_KCCODELINE_, Error::SYSTEM, "stream output error"); + err = true; + } + } else { + err = true; + } + return !err; + } + /** + * Dump records into a file. + * @param dest the path of the destination file. + * @param checker a progress checker object. If it is NULL, no checking is performed. + * @return true on success, or false on failure. + */ + bool dump_snapshot(const std::string& dest, ProgressChecker* checker = NULL) { + _assert_(true); + std::ofstream ofs; + ofs.open(dest.c_str(), std::ios_base::out | std::ios_base::binary | std::ios_base::trunc); + if (!ofs) { + set_error(_KCCODELINE_, Error::NOREPOS, "open failed"); + return false; + } + bool err = false; + if (!dump_snapshot(&ofs, checker)) err = true; + ofs.close(); + if (!ofs) { + set_error(_KCCODELINE_, Error::SYSTEM, "close failed"); + err = true; + } + return !err; + } + /** + * Load records from a data stream. + * @param src the source stream. + * @param checker a progress checker object. If it is NULL, no checking is performed. + * @return true on success, or false on failure. + */ + bool load_snapshot(std::istream* src, ProgressChecker* checker = NULL) { + _assert_(src); + if (src->fail()) { + set_error(_KCCODELINE_, Error::INVALID, "invalid stream"); + return false; + } + char buf[IOBUFSIZ]; + src->read(buf, sizeof(KCDBSSMAGICDATA)); + if (src->fail()) { + set_error(_KCCODELINE_, Error::SYSTEM, "stream input error"); + return false; + } + if (std::memcmp(buf, KCDBSSMAGICDATA, sizeof(KCDBSSMAGICDATA))) { + set_error(_KCCODELINE_, Error::INVALID, "invalid magic data of input stream"); + return false; + } + bool err = false; + if (checker && !checker->check("load_snapshot", "beginning", 0, -1)) { + set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + } + int64_t curcnt = 0; + while (!err) { + int32_t c = src->get(); + if (src->fail()) { + set_error(_KCCODELINE_, Error::SYSTEM, "stream input error"); + err = true; + break; + } + if (c == 0xff) break; + if (c == 0x00) { + size_t ksiz = 0; + do { + c = src->get(); + ksiz = (ksiz << 7) + (c & 0x7f); + } while (c >= 0x80); + size_t vsiz = 0; + do { + c = src->get(); + vsiz = (vsiz << 7) + (c & 0x7f); + } while (c >= 0x80); + size_t rsiz = ksiz + vsiz; + char* rbuf = rsiz > sizeof(buf) ? new char[rsiz] : buf; + src->read(rbuf, ksiz + vsiz); + if (src->fail()) { + set_error(_KCCODELINE_, Error::SYSTEM, "stream input error"); + err = true; + if (rbuf != buf) delete[] rbuf; + break; + } + if (!set(rbuf, ksiz, rbuf + ksiz, vsiz)) { + err = true; + if (rbuf != buf) delete[] rbuf; + break; + } + if (rbuf != buf) delete[] rbuf; + } else { + set_error(_KCCODELINE_, Error::INVALID, "invalid magic data of input stream"); + err = true; + break; + } + curcnt++; + if (checker && !checker->check("load_snapshot", "processing", curcnt, -1)) { + set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + break; + } + } + if (checker && !checker->check("load_snapshot", "ending", -1, -1)) { + set_error(_KCCODELINE_, Error::LOGIC, "checker failed"); + err = true; + } + return !err; + } + /** + * Load records from a file. + * @param src the path of the source file. + * @param checker a progress checker object. If it is NULL, no checking is performed. + * @return true on success, or false on failure. + */ + bool load_snapshot(const std::string& src, ProgressChecker* checker = NULL) { + _assert_(true); + std::ifstream ifs; + ifs.open(src.c_str(), std::ios_base::in | std::ios_base::binary); + if (!ifs) { + set_error(_KCCODELINE_, Error::NOREPOS, "open failed"); + return false; + } + bool err = false; + if (!load_snapshot(&ifs, checker)) err = true; + ifs.close(); + if (ifs.bad()) { + set_error(_KCCODELINE_, Error::SYSTEM, "close failed"); + return false; + } + return !err; + } + /** + * Create a cursor object. + * @return the return value is the created cursor object. + * @note Because the object of the return value is allocated by the constructor, it should be + * released with the delete operator when it is no longer in use. + */ + virtual Cursor* cursor() = 0; + /** + * Write a log message. + * @param file the file name of the program source code. + * @param line the line number of the program source code. + * @param func the function name of the program source code. + * @param kind the kind of the event. Logger::DEBUG for debugging, Logger::INFO for normal + * information, Logger::WARN for warning, and Logger::ERROR for fatal error. + * @param message the supplement message. + */ + virtual void log(const char* file, int32_t line, const char* func, Logger::Kind kind, + const char* message) = 0; + /** + * Set the internal logger. + * @param logger the logger object. + * @param kinds kinds of logged messages by bitwise-or: Logger::DEBUG for debugging, + * Logger::INFO for normal information, Logger::WARN for warning, and Logger::ERROR for fatal + * error. + * @return true on success, or false on failure. + */ + virtual bool tune_logger(Logger* logger, uint32_t kinds = Logger::WARN | Logger::ERROR) = 0; + /** + * Set the internal meta operation trigger. + * @param trigger the trigger object. + * @return true on success, or false on failure. + */ + virtual bool tune_meta_trigger(MetaTrigger* trigger) = 0; + /** + * Get the class name of a database type. + * @param type the database type. + * @return the string of the type name. + */ + static const char* typecname(uint32_t type) { + _assert_(true); + switch (type) { + case TYPEVOID: return "void"; + case TYPEPHASH: return "ProtoHashDB"; + case TYPEPTREE: return "ProtoTreeDB"; + case TYPESTASH: return "StashDB"; + case TYPECACHE: return "CacheDB"; + case TYPEGRASS: return "GrassDB"; + case TYPEHASH: return "HashDB"; + case TYPETREE: return "TreeDB"; + case TYPEDIR: return "DirDB"; + case TYPEFOREST: return "ForestDB"; + case TYPEMISC: return "misc"; + } + return "unknown"; + } + /** + * Get the description string of a database type. + * @param type the database type. + * @return the string of the type name. + */ + static const char* typestring(uint32_t type) { + _assert_(true); + switch (type) { + case TYPEVOID: return "void"; + case TYPEPHASH: return "prototype hash database"; + case TYPEPTREE: return "prototype tree database"; + case TYPESTASH: return "stash database"; + case TYPECACHE: return "cache hash database"; + case TYPEGRASS: return "cache tree database"; + case TYPEHASH: return "file hash database"; + case TYPETREE: return "file tree database"; + case TYPEDIR: return "directory hash database"; + case TYPEFOREST: return "directory tree database"; + case TYPEMISC: return "miscellaneous database"; + } + return "unknown"; + } +}; + + +} // common namespace + +#endif // duplication check + +// END OF FILE |