/*************************************************************************************************
* C language binding
* 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/>.
*************************************************************************************************/
#include "kcpolydb.h"
#include "kcdbext.h"
#include "kclangc.h"
#include "myconf.h"
using namespace kyotocabinet;
extern "C" {
/** The package version. */
const char* const KCVERSION = VERSION;
/** Special pointer for no operation by the visiting function. */
const char* const KCVISNOP = DB::Visitor::NOP;
/** Special pointer to remove the record by the visiting function. */
const char* const KCVISREMOVE = DB::Visitor::REMOVE;
/**
* Allocate a region on memory.
*/
void* kcmalloc(size_t size) {
_assert_(size > 0 && size <= MEMMAXSIZ);
return new char[size];
}
/**
* Release a region allocated in the library.
*/
void kcfree(void* ptr) {
_assert_(true);
delete[] (char*)ptr;
}
/**
* Get the time of day in seconds.
*/
double kctime(void) {
_assert_(true);
return kyotocabinet::time();
}
/**
* Convert a string to an integer.
*/
int64_t kcatoi(const char* str) {
_assert_(str);
return kyotocabinet::atoi(str);
}
/**
* Convert a string with a metric prefix to an integer.
*/
int64_t kcatoix(const char* str) {
_assert_(str);
return kyotocabinet::atoix(str);
}
/**
* Convert a string to a real number.
*/
double kcatof(const char* str) {
_assert_(str);
return kyotocabinet::atof(str);
}
/**
* Get the hash value by MurMur hashing.
*/
uint64_t kchashmurmur(const void* buf, size_t size) {
_assert_(buf && size <= MEMMAXSIZ);
return kyotocabinet::hashmurmur(buf, size);
}
/**
* Get the hash value by FNV hashing.
*/
uint64_t kchashfnv(const void* buf, size_t size) {
_assert_(buf && size <= MEMMAXSIZ);
return kyotocabinet::hashfnv(buf, size);
}
/**
* Calculate the levenshtein distance of two regions.
*/
size_t kclevdist(const void* abuf, size_t asiz, const void* bbuf, size_t bsiz, int32_t utf) {
_assert_(abuf && asiz <= MEMMAXSIZ && bbuf && bsiz <= MEMMAXSIZ);
size_t dist;
if (utf) {
uint32_t astack[128];
uint32_t* aary = asiz > sizeof(astack) / sizeof(*astack) ? new uint32_t[asiz] : astack;
size_t anum;
strutftoucs((const char*)abuf, asiz, aary, &anum);
uint32_t bstack[128];
uint32_t* bary = bsiz > sizeof(bstack) / sizeof(*bstack) ? new uint32_t[bsiz] : bstack;
size_t bnum;
strutftoucs((const char*)bbuf, bsiz, bary, &bnum);
dist = strucsdist(aary, anum, bary, bnum);
if (bary != bstack) delete[] bary;
if (aary != astack) delete[] aary;
} else {
dist = memdist(abuf, asiz, bbuf, bsiz);
}
return dist;
}
/**
* Get the quiet Not-a-Number value.
*/
double kcnan() {
_assert_(true);
return kyotocabinet::nan();
}
/**
* Get the positive infinity value.
*/
double kcinf() {
_assert_(true);
return kyotocabinet::inf();
}
/**
* Check a number is a Not-a-Number value.
*/
int32_t kcchknan(double num) {
_assert_(true);
return kyotocabinet::chknan(num);
}
/**
* Check a number is an infinity value.
*/
int32_t kcchkinf(double num) {
_assert_(true);
return kyotocabinet::chkinf(num);
}
/**
* Get the readable string of an error code.
*/
const char* kcecodename(int32_t code) {
_assert_(true);
return BasicDB::Error::codename((BasicDB::Error::Code)code);
}
/**
* Create a database object.
*/
KCDB* kcdbnew(void) {
_assert_(true);
return (KCDB*)new PolyDB;
}
/**
* Destroy a database object.
*/
void kcdbdel(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
delete pdb;
}
/**
* Open a database file.
*/
int32_t kcdbopen(KCDB* db, const char* path, uint32_t mode) {
_assert_(db && path);
PolyDB* pdb = (PolyDB*)db;
return pdb->open(path, mode);
}
/**
* Close the database file.
*/
int32_t kcdbclose(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->close();
}
/**
* Get the code of the last happened error.
*/
int32_t kcdbecode(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->error().code();
}
/**
* Get the supplement message of the last happened error.
*/
const char* kcdbemsg(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->error().message();
}
/**
* Accept a visitor to a record.
*/
int32_t kcdbaccept(KCDB* db, const char* kbuf, size_t ksiz,
KCVISITFULL fullproc, KCVISITEMPTY emptyproc, void* opq, int32_t writable) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
class VisitorImpl : public DB::Visitor {
public:
explicit VisitorImpl(KCVISITFULL fullproc, KCVISITEMPTY emptyproc, void* opq) :
fullproc_(fullproc), emptyproc_(emptyproc), opq_(opq) {}
const char* visit_full(const char* kbuf, size_t ksiz,
const char* vbuf, size_t vsiz, size_t* sp) {
if (!fullproc_) return NOP;
return fullproc_(kbuf, ksiz, vbuf, vsiz, sp, opq_);
}
const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) {
if (!emptyproc_) return NOP;
return emptyproc_(kbuf, ksiz, sp, opq_);
}
private:
KCVISITFULL fullproc_;
KCVISITEMPTY emptyproc_;
void* opq_;
};
VisitorImpl visitor(fullproc, emptyproc, opq);
return pdb->accept(kbuf, ksiz, &visitor, writable);
}
/**
* Accept a visitor to multiple records at once.
*/
int32_t kcdbacceptbulk(KCDB* db, const KCSTR* keys, size_t knum,
KCVISITFULL fullproc, KCVISITEMPTY emptyproc,
void* opq, int32_t writable) {
_assert_(db && keys && knum <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
std::vector<std::string> xkeys;
xkeys.reserve(knum);
for (size_t i = 0; i < knum; i++) {
xkeys.push_back(std::string(keys[i].buf, keys[i].size));
}
class VisitorImpl : public DB::Visitor {
public:
explicit VisitorImpl(KCVISITFULL fullproc, KCVISITEMPTY emptyproc, void* opq) :
fullproc_(fullproc), emptyproc_(emptyproc), opq_(opq) {}
const char* visit_full(const char* kbuf, size_t ksiz,
const char* vbuf, size_t vsiz, size_t* sp) {
if (!fullproc_) return NOP;
return fullproc_(kbuf, ksiz, vbuf, vsiz, sp, opq_);
}
const char* visit_empty(const char* kbuf, size_t ksiz, size_t* sp) {
if (!emptyproc_) return NOP;
return emptyproc_(kbuf, ksiz, sp, opq_);
}
private:
KCVISITFULL fullproc_;
KCVISITEMPTY emptyproc_;
void* opq_;
};
VisitorImpl visitor(fullproc, emptyproc, opq);
return pdb->accept_bulk(xkeys, &visitor, writable);
}
/**
* Iterate to accept a visitor for each record.
*/
int32_t kcdbiterate(KCDB* db, KCVISITFULL fullproc, void* opq, int32_t writable) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
class VisitorImpl : public DB::Visitor {
public:
explicit VisitorImpl(KCVISITFULL fullproc, void* opq) : fullproc_(fullproc), opq_(opq) {}
const char* visit_full(const char* kbuf, size_t ksiz,
const char* vbuf, size_t vsiz, size_t* sp) {
if (!fullproc_) return NOP;
return fullproc_(kbuf, ksiz, vbuf, vsiz, sp, opq_);
}
private:
KCVISITFULL fullproc_;
void* opq_;
};
VisitorImpl visitor(fullproc, opq);
return pdb->iterate(&visitor, writable);
}
/**
* Scan each record in parallel.
*/
int32_t kcdbscanpara(KCDB* db, KCVISITFULL fullproc, void* opq, size_t thnum) {
_assert_(db && thnum <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
class VisitorImpl : public DB::Visitor {
public:
explicit VisitorImpl(KCVISITFULL fullproc, void* opq) : fullproc_(fullproc), opq_(opq) {}
const char* visit_full(const char* kbuf, size_t ksiz,
const char* vbuf, size_t vsiz, size_t* sp) {
if (!fullproc_) return NOP;
return fullproc_(kbuf, ksiz, vbuf, vsiz, sp, opq_);
}
private:
KCVISITFULL fullproc_;
void* opq_;
};
VisitorImpl visitor(fullproc, opq);
return pdb->scan_parallel(&visitor, thnum);
}
/**
* Set the value of a record.
*/
int32_t kcdbset(KCDB* db, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->set(kbuf, ksiz, vbuf, vsiz);
}
/**
* Add a record.
*/
int32_t kcdbadd(KCDB* db, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->add(kbuf, ksiz, vbuf, vsiz);
}
/**
* Replace the value of a record.
*/
int32_t kcdbreplace(KCDB* db, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->replace(kbuf, ksiz, vbuf, vsiz);
}
/**
* Append the value of a record.
*/
int32_t kcdbappend(KCDB* db, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->append(kbuf, ksiz, vbuf, vsiz);
}
/**
* Add a number to the numeric value of a record.
*/
int64_t kcdbincrint(KCDB* db, const char* kbuf, size_t ksiz, int64_t num, int64_t orig) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->increment(kbuf, ksiz, num, orig);
}
/**
* Add a number to the numeric value of a record.
*/
double kcdbincrdouble(KCDB* db, const char* kbuf, size_t ksiz, double num, double orig) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->increment_double(kbuf, ksiz, num, orig);
}
/**
* Perform compare-and-swap.
*/
int32_t kcdbcas(KCDB* db, const char* kbuf, size_t ksiz,
const char* ovbuf, size_t ovsiz, const char* nvbuf, size_t nvsiz) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->cas(kbuf, ksiz, ovbuf, ovsiz, nvbuf, nvsiz);
}
/**
* Remove a record.
*/
int32_t kcdbremove(KCDB* db, const char* kbuf, size_t ksiz) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->remove(kbuf, ksiz);
}
/**
* Retrieve the value of a record.
*/
char* kcdbget(KCDB* db, const char* kbuf, size_t ksiz, size_t* sp) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ && sp);
PolyDB* pdb = (PolyDB*)db;
return pdb->get(kbuf, ksiz, sp);
}
/**
* Check the existence of a record.
*/
int32_t kcdbcheck(KCDB* db, const char* kbuf, size_t ksiz) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->check(kbuf, ksiz);
}
/**
* Retrieve the value of a record.
*/
int32_t kcdbgetbuf(KCDB* db, const char* kbuf, size_t ksiz, char* vbuf, size_t max) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ && vbuf);
PolyDB* pdb = (PolyDB*)db;
return pdb->get(kbuf, ksiz, vbuf, max);
}
/**
* Retrieve the value of a record and remove it atomically.
*/
char* kcdbseize(KCDB* db, const char* kbuf, size_t ksiz, size_t* sp) {
_assert_(db && kbuf && ksiz <= MEMMAXSIZ && sp);
PolyDB* pdb = (PolyDB*)db;
return pdb->seize(kbuf, ksiz, sp);
}
/**
* Store records at once.
*/
int64_t kcdbsetbulk(KCDB* db, const KCREC* recs, size_t rnum, int32_t atomic) {
_assert_(db && recs && rnum <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
std::map<std::string, std::string> xrecs;
for (size_t i = 0; i < rnum; i++) {
const KCREC* rec = recs + i;
xrecs[std::string(rec->key.buf, rec->key.size)] =
std::string(rec->value.buf, rec->value.size);
}
return pdb->set_bulk(xrecs, atomic);
}
/**
* Remove records at once.
*/
int64_t kcdbremovebulk(KCDB* db, const KCSTR* keys, size_t knum, int32_t atomic) {
_assert_(db && keys && knum <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
std::vector<std::string> xkeys;
xkeys.reserve(knum);
for (size_t i = 0; i < knum; i++) {
const KCSTR* key = keys + i;
xkeys.push_back(std::string(key->buf, key->size));
}
return pdb->remove_bulk(xkeys, atomic);
}
/**
* Retrieve records at once.
*/
int64_t kcdbgetbulk(KCDB* db, const KCSTR* keys, size_t knum, KCREC* recs, int32_t atomic) {
_assert_(db && keys && knum <= MEMMAXSIZ && recs);
PolyDB* pdb = (PolyDB*)db;
std::vector<std::string> xkeys;
xkeys.reserve(knum);
for (size_t i = 0; i < knum; i++) {
const KCSTR* key = keys + i;
xkeys.push_back(std::string(key->buf, key->size));
}
std::map<std::string, std::string> xrecs;
if (pdb->get_bulk(xkeys, &xrecs, atomic) < 0) return -1;
std::map<std::string, std::string>::iterator it = xrecs.begin();
std::map<std::string, std::string>::iterator itend = xrecs.end();
size_t ridx = 0;
while (ridx < knum && it != itend) {
size_t ksiz = it->first.size();
char* kbuf = new char[ksiz+1];
std::memcpy(kbuf, it->first.data(), ksiz);
kbuf[ksiz] = '\0';
size_t vsiz = it->second.size();
char* vbuf = new char[vsiz+1];
std::memcpy(vbuf, it->second.data(), vsiz);
vbuf[vsiz] = '\0';
KCREC* rec = recs + (ridx++);
rec->key.buf = kbuf;
rec->key.size = ksiz;
rec->value.buf = vbuf;
rec->value.size = vsiz;
++it;
}
return ridx;
}
/**
* Synchronize updated contents with the file and the device.
*/
int32_t kcdbsync(KCDB* db, int32_t hard, KCFILEPROC proc, void* opq) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
class FileProcessorImpl : public BasicDB::FileProcessor {
public:
explicit FileProcessorImpl(KCFILEPROC proc, void* opq) : proc_(proc), opq_(opq) {}
bool process(const std::string& path, int64_t count, int64_t size) {
if (!proc_) return true;
return proc_(path.c_str(), count, size, opq_);
}
private:
KCFILEPROC proc_;
void* opq_;
};
FileProcessorImpl myproc(proc, opq);
return pdb->synchronize(hard, &myproc);
}
/**
* Occupy database by locking and do something meanwhile.
*/
int32_t kcdboccupy(KCDB* db, int32_t writable, KCFILEPROC proc, void* opq) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
class FileProcessorImpl : public BasicDB::FileProcessor {
public:
explicit FileProcessorImpl(KCFILEPROC proc, void* opq) : proc_(proc), opq_(opq) {}
bool process(const std::string& path, int64_t count, int64_t size) {
if (!proc_) return true;
return proc_(path.c_str(), count, size, opq_);
}
private:
KCFILEPROC proc_;
void* opq_;
};
FileProcessorImpl myproc(proc, opq);
return pdb->occupy(writable, &myproc);
}
/**
* Create a copy of the database file.
*/
int32_t kcdbcopy(KCDB* db, const char* dest) {
_assert_(db && dest);
PolyDB* pdb = (PolyDB*)db;
return pdb->copy(dest);
}
/**
* Begin transaction.
*/
int32_t kcdbbegintran(KCDB* db, int32_t hard) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->begin_transaction(hard);
}
/**
* Try to begin transaction.
*/
int32_t kcdbbegintrantry(KCDB* db, int32_t hard) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->begin_transaction_try(hard);
}
/**
* End transaction.
*/
int32_t kcdbendtran(KCDB* db, int32_t commit) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->end_transaction(commit);
}
/**
* Remove all records.
*/
int32_t kcdbclear(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->clear();
}
/**
* Dump records into a file.
*/
int32_t kcdbdumpsnap(KCDB* db, const char* dest) {
_assert_(db && dest);
PolyDB* pdb = (PolyDB*)db;
return pdb->dump_snapshot(dest);
}
/**
* Load records from a file.
*/
int32_t kcdbloadsnap(KCDB* db, const char* src) {
_assert_(db && src);
PolyDB* pdb = (PolyDB*)db;
return pdb->load_snapshot(src);
}
/**
* Get the number of records.
*/
int64_t kcdbcount(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->count();
}
/**
* Get the size of the database file.
*/
int64_t kcdbsize(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return pdb->size();
}
/**
* Get the path of the database file.
*/
char* kcdbpath(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
std::string path = pdb->path();
size_t psiz = path.size();
char* pbuf = new char[psiz+1];
std::memcpy(pbuf, path.c_str(), psiz + 1);
return pbuf;
}
/**
* Get the miscellaneous status information.
*/
char* kcdbstatus(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
std::map<std::string, std::string> status;
if (!pdb->status(&status)) return NULL;
std::ostringstream obuf;
std::map<std::string, std::string>::iterator it = status.begin();
std::map<std::string, std::string>::iterator itend = status.end();
while (it != itend) {
obuf << it->first << "\t" << it->second << "\n";
++it;
}
std::string sstr = obuf.str();
size_t ssiz = sstr.size();
char* sbuf = new char[ssiz+1];
std::memcpy(sbuf, sstr.c_str(), ssiz + 1);
return sbuf;
}
/**
* Get keys matching a prefix string.
*/
int64_t kcdbmatchprefix(KCDB* db, const char* prefix, char** strary, size_t max) {
_assert_(db && prefix && strary && max <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
std::vector<std::string> strvec;
if (pdb->match_prefix(prefix, &strvec, max) == -1) return -1;
int64_t cnt = 0;
std::vector<std::string>::iterator it = strvec.begin();
std::vector<std::string>::iterator itend = strvec.end();
while (it != itend) {
size_t ksiz = it->size();
char* kbuf = new char[ksiz+1];
std::memcpy(kbuf, it->data(), ksiz);
kbuf[ksiz] = '\0';
strary[cnt++] = kbuf;
++it;
}
return cnt;
}
/**
* Get keys matching a regular expression string.
*/
int64_t kcdbmatchregex(KCDB* db, const char* regex, char** strary, size_t max) {
_assert_(db && regex && strary && max <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
std::vector<std::string> strvec;
if (pdb->match_regex(regex, &strvec, max) == -1) return -1;
int64_t cnt = 0;
std::vector<std::string>::iterator it = strvec.begin();
std::vector<std::string>::iterator itend = strvec.end();
while (it != itend) {
size_t ksiz = it->size();
char* kbuf = new char[ksiz+1];
std::memcpy(kbuf, it->data(), ksiz);
kbuf[ksiz] = '\0';
strary[cnt++] = kbuf;
++it;
}
return cnt;
}
/**
* Get keys similar to a string in terms of the levenshtein distance.
*/
int64_t kcdbmatchsimilar(KCDB* db, const char* origin, uint32_t range, int32_t utf,
char** strary, size_t max) {
_assert_(db && origin && strary && max <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
std::vector<std::string> strvec;
if (pdb->match_similar(origin, range, utf, &strvec, max) == -1) return -1;
int64_t cnt = 0;
std::vector<std::string>::iterator it = strvec.begin();
std::vector<std::string>::iterator itend = strvec.end();
while (it != itend) {
size_t ksiz = it->size();
char* kbuf = new char[ksiz+1];
std::memcpy(kbuf, it->data(), ksiz);
kbuf[ksiz] = '\0';
strary[cnt++] = kbuf;
++it;
}
return cnt;
}
/**
* Merge records from other databases.
*/
int32_t kcdbmerge(KCDB* db, KCDB** srcary, size_t srcnum, uint32_t mode) {
_assert_(db && srcary && srcnum <= MEMMAXSIZ);
PolyDB* pdb = (PolyDB*)db;
return pdb->merge((BasicDB**)srcary, srcnum, (PolyDB::MergeMode)mode);
}
/**
* Create a cursor object.
*/
KCCUR* kcdbcursor(KCDB* db) {
_assert_(db);
PolyDB* pdb = (PolyDB*)db;
return (KCCUR*)pdb->cursor();
}
/**
* Destroy a cursor object.
*/
void kccurdel(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
delete pcur;
}
/**
* Accept a visitor to the current record.
*/
int32_t kccuraccept(KCCUR* cur, KCVISITFULL fullproc, void* opq,
int32_t writable, int32_t step) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
class VisitorImpl : public DB::Visitor {
public:
explicit VisitorImpl(KCVISITFULL fullproc, void* opq) : fullproc_(fullproc), opq_(opq) {}
const char* visit_full(const char* kbuf, size_t ksiz,
const char* vbuf, size_t vsiz, size_t* sp) {
if (!fullproc_) return NOP;
return fullproc_(kbuf, ksiz, vbuf, vsiz, sp, opq_);
}
private:
KCVISITFULL fullproc_;
void* opq_;
};
VisitorImpl visitor(fullproc, opq);
return pcur->accept(&visitor, writable, step);
}
/**
* Set the value of the current record.
*/
int32_t kccursetvalue(KCCUR* cur, const char* vbuf, size_t vsiz, int32_t step) {
_assert_(cur && vbuf && vsiz <= MEMMAXSIZ);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->set_value(vbuf, vsiz, step);
}
/**
* Remove the current record.
*/
int32_t kccurremove(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->remove();
}
/**
* Get the key of the current record.
*/
char* kccurgetkey(KCCUR* cur, size_t* sp, int32_t step) {
_assert_(cur && sp);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->get_key(sp, step);
}
/**
* Get the value of the current record.
*/
char* kccurgetvalue(KCCUR* cur, size_t* sp, int32_t step) {
_assert_(cur && sp);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->get_value(sp, step);
}
/**
* Get a pair of the key and the value of the current record.
*/
char* kccurget(KCCUR* cur, size_t* ksp, const char** vbp, size_t* vsp, int32_t step) {
_assert_(cur && ksp && vbp && vsp);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->get(ksp, vbp, vsp, step);
}
/**
* Get a pair of the key and the value of the current record and remove it atomically.
*/
char* kccurseize(KCCUR* cur, size_t* ksp, const char** vbp, size_t* vsp) {
_assert_(cur && ksp && vbp && vsp);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->seize(ksp, vbp, vsp);
}
/**
* Jump the cursor to the first record.
*/
int32_t kccurjump(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->jump();
}
/**
* Jump the cursor to a record.
*/
int32_t kccurjumpkey(KCCUR* cur, const char* kbuf, size_t ksiz) {
_assert_(cur && kbuf && ksiz <= MEMMAXSIZ);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->jump(kbuf, ksiz);
}
/**
* Jump the cursor to the last record for backward scan.
*/
int32_t kccurjumpback(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->jump_back();
}
/**
* Jump the cursor to a record for backward scan.
*/
int32_t kccurjumpbackkey(KCCUR* cur, const char* kbuf, size_t ksiz) {
_assert_(cur && kbuf && ksiz <= MEMMAXSIZ);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->jump_back(kbuf, ksiz);
}
/**
* Step the cursor to the next record.
*/
int32_t kccurstep(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->step();
}
/**
* Step the cursor to the previous record.
*/
int32_t kccurstepback(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->step_back();
}
/**
* Get the database object.
*/
KCDB* kccurdb(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return (KCDB*)pcur->db();
}
/**
* Get the code of the last happened error.
*/
int32_t kccurecode(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->error().code();
}
/**
* Get the supplement message of the last happened error.
*/
const char* kccuremsg(KCCUR* cur) {
_assert_(cur);
PolyDB::Cursor* pcur = (PolyDB::Cursor*)cur;
return pcur->error().message();
}
/**
* Create an index database object.
*/
KCIDX* kcidxnew(void) {
_assert_(true);
return (KCIDX*)new IndexDB;
}
/**
* Destroy a database object.
*/
void kcidxdel(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
delete idb;
}
/**
* Open a database file.
*/
int32_t kcidxopen(KCIDX* idx, const char* path, uint32_t mode) {
_assert_(idx && path);
IndexDB* idb = (IndexDB*)idx;
return idb->open(path, mode);
}
/**
* Close the database file.
*/
int32_t kcidxclose(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
return idb->close();
}
/**
* Get the code of the last happened error.
*/
int32_t kcidxecode(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
return idb->error().code();
}
/**
* Get the supplement message of the last happened error.
*/
const char* kcidxemsg(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
return idb->error().message();
}
/**
* Set the value of a record.
*/
int32_t kcidxset(KCIDX* idx, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(idx && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
IndexDB* idb = (IndexDB*)idx;
return idb->set(kbuf, ksiz, vbuf, vsiz);
}
/**
* Add a record.
*/
int32_t kcidxadd(KCIDX* idx, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(idx && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
IndexDB* idb = (IndexDB*)idx;
return idb->add(kbuf, ksiz, vbuf, vsiz);
}
/**
* Replace the value of a record.
*/
int32_t kcidxreplace(KCIDX* idx, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(idx && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
IndexDB* idb = (IndexDB*)idx;
return idb->replace(kbuf, ksiz, vbuf, vsiz);
}
/**
* Append the value of a record.
*/
int32_t kcidxappend(KCIDX* idx, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(idx && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
IndexDB* idb = (IndexDB*)idx;
return idb->append(kbuf, ksiz, vbuf, vsiz);
}
/**
* Remove a record.
*/
int32_t kcidxremove(KCIDX* idx, const char* kbuf, size_t ksiz) {
_assert_(idx && kbuf && ksiz <= MEMMAXSIZ);
IndexDB* idb = (IndexDB*)idx;
return idb->remove(kbuf, ksiz);
}
/**
* Retrieve the value of a record.
*/
char* kcidxget(KCIDX* idx, const char* kbuf, size_t ksiz, size_t* sp) {
_assert_(idx && kbuf && ksiz <= MEMMAXSIZ && sp);
IndexDB* idb = (IndexDB*)idx;
return idb->get(kbuf, ksiz, sp);
}
/**
* Synchronize updated contents with the file and the device.
*/
int32_t kcidxsync(KCIDX* idx, int32_t hard, KCFILEPROC proc, void* opq) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
class FileProcessorImpl : public BasicDB::FileProcessor {
public:
explicit FileProcessorImpl(KCFILEPROC proc, void* opq) : proc_(proc), opq_(opq) {}
bool process(const std::string& path, int64_t count, int64_t size) {
if (!proc_) return true;
return proc_(path.c_str(), count, size, opq_);
}
private:
KCFILEPROC proc_;
void* opq_;
};
FileProcessorImpl myproc(proc, opq);
return idb->synchronize(hard, &myproc);
}
/**
* Remove all records.
*/
int32_t kcidxclear(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
return idb->clear();
}
/**
* Get the number of records.
*/
int64_t kcidxcount(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
return idb->count();
}
/**
* Get the size of the database file.
*/
int64_t kcidxsize(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
return idb->size();
}
/**
* Get the path of the database file.
*/
char* kcidxpath(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
std::string path = idb->path();
size_t psiz = path.size();
char* pbuf = new char[psiz+1];
std::memcpy(pbuf, path.c_str(), psiz + 1);
return pbuf;
}
/**
* Get the miscellaneous status information.
*/
char* kcidxstatus(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
std::map<std::string, std::string> status;
if (!idb->status(&status)) return NULL;
std::ostringstream obuf;
std::map<std::string, std::string>::iterator it = status.begin();
std::map<std::string, std::string>::iterator itend = status.end();
while (it != itend) {
obuf << it->first << "\t" << it->second << "\n";
++it;
}
std::string sstr = obuf.str();
size_t ssiz = sstr.size();
char* sbuf = new char[ssiz+1];
std::memcpy(sbuf, sstr.c_str(), ssiz + 1);
return sbuf;
}
/**
* Reveal the inner database object.
*/
KCDB* kcidxrevealinnerdb(KCIDX* idx) {
_assert_(idx);
IndexDB* idb = (IndexDB*)idx;
return (KCDB*)idb->reveal_inner_db();
}
/**
* Create a string hash map object.
*/
KCMAP* kcmapnew(size_t bnum) {
_assert_(true);
return (KCMAP*)new TinyHashMap(bnum);
}
/**
* Destroy a map object.
*/
void kcmapdel(KCMAP* map) {
_assert_(map);
TinyHashMap* thm = (TinyHashMap*)map;
delete thm;
}
/**
* Set the value of a record.
*/
void kcmapset(KCMAP* map, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(map && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
TinyHashMap* thm = (TinyHashMap*)map;
thm->set(kbuf, ksiz, vbuf, vsiz);
}
/**
* Add a record.
*/
int32_t kcmapadd(KCMAP* map, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(map && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
TinyHashMap* thm = (TinyHashMap*)map;
return thm->add(kbuf, ksiz, vbuf, vsiz);
}
/**
* Replace the value of a record.
*/
int32_t kcmapreplace(KCMAP* map, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(map && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
TinyHashMap* thm = (TinyHashMap*)map;
return thm->replace(kbuf, ksiz, vbuf, vsiz);
}
/**
* Append the value of a record.
*/
void kcmapappend(KCMAP* map, const char* kbuf, size_t ksiz, const char* vbuf, size_t vsiz) {
_assert_(map && kbuf && ksiz <= MEMMAXSIZ && vbuf && vsiz <= MEMMAXSIZ);
TinyHashMap* thm = (TinyHashMap*)map;
thm->append(kbuf, ksiz, vbuf, vsiz);
}
/**
* Remove a record.
*/
int32_t kcmapremove(KCMAP* map, const char* kbuf, size_t ksiz) {
_assert_(map && kbuf && ksiz <= MEMMAXSIZ);
TinyHashMap* thm = (TinyHashMap*)map;
return thm->remove(kbuf, ksiz);
}
/**
* Retrieve the value of a record.
*/
const char* kcmapget(KCMAP* map, const char* kbuf, size_t ksiz, size_t* sp) {
_assert_(map && kbuf && ksiz <= MEMMAXSIZ && sp);
TinyHashMap* thm = (TinyHashMap*)map;
return thm->get(kbuf, ksiz, sp);
}
/**
* Remove all records.
*/
void kcmapclear(KCMAP* map) {
_assert_(map);
TinyHashMap* thm = (TinyHashMap*)map;
thm->clear();
}
/**
* Get the number of records.
*/
size_t kcmapcount(KCMAP* map) {
_assert_(map);
TinyHashMap* thm = (TinyHashMap*)map;
return thm->count();
}
/**
* Create a string hash map iterator object.
*/
KCMAPITER* kcmapiterator(KCMAP* map) {
_assert_(map);
TinyHashMap* thm = (TinyHashMap*)map;
return (KCMAPITER*)new TinyHashMap::Iterator(thm);
}
/**
* Destroy an iterator object.
*/
void kcmapiterdel(KCMAPITER* iter) {
_assert_(iter);
TinyHashMap::Iterator* thmi = (TinyHashMap::Iterator*)iter;
delete thmi;
}
/**
* Get the key of the current record.
*/
const char* kcmapitergetkey(KCMAPITER* iter, size_t* sp) {
_assert_(iter && sp);
TinyHashMap::Iterator* thmi = (TinyHashMap::Iterator*)iter;
return thmi->get_key(sp);
}
/**
* Get the value of the current record.
*/
const char* kcmapitergetvalue(KCMAPITER* iter, size_t* sp) {
_assert_(iter && sp);
TinyHashMap::Iterator* thmi = (TinyHashMap::Iterator*)iter;
return thmi->get_value(sp);
}
/**
* Get a pair of the key and the value of the current record.
*/
const char* kcmapiterget(KCMAPITER* iter, size_t* ksp, const char** vbp, size_t* vsp) {
_assert_(iter && ksp && vbp && vsp);
TinyHashMap::Iterator* thmi = (TinyHashMap::Iterator*)iter;
return thmi->get(ksp, vbp, vsp);
}
/**
* Step the cursor to the next record.
*/
void kcmapiterstep(KCMAPITER* iter) {
_assert_(iter);
TinyHashMap::Iterator* thmi = (TinyHashMap::Iterator*)iter;
return thmi->step();
}
/**
* Create a string hash map sorter object.
*/
KCMAPSORT* kcmapsorter(KCMAP* map) {
_assert_(map);
TinyHashMap* thm = (TinyHashMap*)map;
return (KCMAPSORT*)new TinyHashMap::Sorter(thm);
}
/**
* Destroy an sorter object.
*/
void kcmapsortdel(KCMAPSORT* sort) {
_assert_(sort);
TinyHashMap::Sorter* thms = (TinyHashMap::Sorter*)sort;
delete thms;
}
/**
* Get the key of the current record.
*/
const char* kcmapsortgetkey(KCMAPSORT* sort, size_t* sp) {
_assert_(sort && sp);
TinyHashMap::Sorter* thms = (TinyHashMap::Sorter*)sort;
return thms->get_key(sp);
}
/**
* Get the value of the current record.
*/
const char* kcmapsortgetvalue(KCMAPSORT* sort, size_t* sp) {
_assert_(sort && sp);
TinyHashMap::Sorter* thms = (TinyHashMap::Sorter*)sort;
return thms->get_value(sp);
}
/**
* Get a pair of the key and the value of the current record.
*/
const char* kcmapsortget(KCMAPSORT* sort, size_t* ksp, const char** vbp, size_t* vsp) {
_assert_(sort && ksp && vbp && vsp);
TinyHashMap::Sorter* thms = (TinyHashMap::Sorter*)sort;
return thms->get(ksp, vbp, vsp);
}
/**
* Step the cursor to the next record.
*/
void kcmapsortstep(KCMAPSORT* sort) {
_assert_(sort);
TinyHashMap::Sorter* thms = (TinyHashMap::Sorter*)sort;
return thms->step();
}
/**
* Create a string array list object.
*/
KCLIST* kclistnew() {
_assert_(true);
return (KCLIST*)new TinyArrayList();
}
/**
* Destroy a list object.
*/
void kclistdel(KCLIST* list) {
_assert_(list);
TinyArrayList* tal = (TinyArrayList*)list;
delete tal;
}
/**
* Insert a record at the bottom of the list.
*/
void kclistpush(KCLIST* list, const char* buf, size_t size) {
_assert_(list && buf && size <= MEMMAXSIZ);
TinyArrayList* tal = (TinyArrayList*)list;
tal->push(buf, size);
}
/**
* Remove a record at the bottom of the list.
*/
int32_t kclistpop(KCLIST* list) {
_assert_(list);
TinyArrayList* tal = (TinyArrayList*)list;
return tal->pop();
}
/**
* Insert a record at the top of the list.
*/
void kclistunshift(KCLIST* list, const char* buf, size_t size) {
_assert_(list && buf && size <= MEMMAXSIZ);
TinyArrayList* tal = (TinyArrayList*)list;
tal->unshift(buf, size);
}
/**
* Remove a record at the top of the list.
*/
int32_t kclistshift(KCLIST* list) {
_assert_(list);
TinyArrayList* tal = (TinyArrayList*)list;
return tal->shift();
}
/**
* Insert a record at the position of the given index of the list.
*/
void kclistinsert(KCLIST* list, const char* buf, size_t size, size_t idx) {
_assert_(list && buf && size <= MEMMAXSIZ);
TinyArrayList* tal = (TinyArrayList*)list;
tal->insert(buf, size, idx);
}
/**
* Remove a record at the position of the given index of the list.
*/
void kclistremove(KCLIST* list, size_t idx) {
_assert_(list);
TinyArrayList* tal = (TinyArrayList*)list;
return tal->remove(idx);
}
/**
* Retrieve a record at the position of the given index of the list.
*/
const char* kclistget(KCLIST* list, size_t idx, size_t* sp) {
_assert_(list && sp);
TinyArrayList* tal = (TinyArrayList*)list;
return tal->get(idx, sp);
}
/**
* Remove all records.
*/
void kclistclear(KCLIST* list) {
_assert_(list);
TinyArrayList* tal = (TinyArrayList*)list;
tal->clear();
}
/**
* Get the number of records.
*/
size_t kclistcount(KCLIST* list) {
_assert_(list);
TinyArrayList* tal = (TinyArrayList*)list;
return tal->count();
}
}
// END OF FILE