- 浏览: 246867 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
satan_1st:
据说可以用(*this)取得当前的lambda。
Recursive Lambda in C++ -
febird:
微软不死, 天理难容
再抱怨一下Windows7 -
sunzixun:
很有见解ace也可以精简的,我们就用阉割版的
asio/ACE/apr/libevent -
febird:
hamo2008 写道用win7以来基本上没有遇到这种情况了我 ...
造 windows 的微软很脑残 -
hamo2008:
用win7以来基本上没有遇到这种情况了
造 windows 的微软很脑残
项目地址:http://code.google.com/p/febird
如前介绍,相当于 std::map<Key1,std::map<Key2,Data> >,但接口也不完全相同,这里只贴代码:
- /* vim: set tabstop=4 : */
- #ifndef __febird_bdb_kmapdset_h__
- #define __febird_bdb_kmapdset_h__
- #if defined(_MSC_VER) && (_MSC_VER >= 1020)
- # pragma once
- #endif
- #include <db_cxx.h>
- #include "native_compare.h"
- #include "../io/DataIO.h"
- #include "../io/MemStream.h"
- #include "../refcount.h"
- namespace febird {
- class FEBIRD_DLL_EXPORT kmapdset_iterator_impl_base : public RefCounter
- {
- public:
- class kmapdset_base* m_owner;
- DBC* m_curp;
- int m_ret;
- DBT m_bulk;
- public:
- kmapdset_iterator_impl_base(class kmapdset_base* owner);
- void init(DB* dbp, DB_TXN* txn, const char* func);
- virtual ~kmapdset_iterator_impl_base();
- virtual void clear_vec() = 0;
- virtual void push_back(void* data, size_t size) = 0;
- virtual void load_key1(void* data, size_t size) = 0;
- virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& oKey) = 0;
- bool next_key(size_t* cnt, const char* func);
- void bulk_load(DBT* tk1);
- void increment(const char* func);
- void decrement(const char* func);
- bool find_pos(const void* k1, const void* k2, bool bulk, const char* func);
- bool insert(const void* d, const char* func);
- bool update(const void* d, const char* func);
- bool replace(const void* d, const char* func);
- bool remove(const void* k2, const char* func);
- bool remove(const char* func);
- };
- class FEBIRD_DLL_EXPORT kmapdset_base
- {
- DECLARE_NONE_COPYABLE_CLASS(kmapdset_base)
- public:
- DB* m_db;
- size_t m_bulkSize;
- bt_compare_fcn_type m_bt_comp, m_dup_comp;
- kmapdset_base(DB_ENV* env, const char* dbname
- , DB_TXN* txn
- , bt_compare_fcn_type bt_comp
- , bt_compare_fcn_type dup_comp
- , const char* func
- );
- virtual ~kmapdset_base();
- virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& dio, const void* key1) const = 0;
- virtual void save_key2(PortableDataOutput<AutoGrownMemIO>& dio, const void* key2) const = 0;
- virtual void save_data(PortableDataOutput<AutoGrownMemIO>& dio, const void* data) const = 0;
- virtual kmapdset_iterator_impl_base* make_iter() = 0;
- kmapdset_iterator_impl_base* begin_impl(DB_TXN* txn, const char* func);
- kmapdset_iterator_impl_base* end_impl(DB_TXN* txn, const char* func);
- kmapdset_iterator_impl_base* find_impl(const void* k1, DB_TXN* txn, u_int32_t flags, const char* func);
- kmapdset_iterator_impl_base* find_impl(const void* k1, const void* k2, DB_TXN* txn, bool bulk, const char* func);
- kmapdset_iterator_impl_base* upper_bound_impl(const void* k1, DB_TXN* txn, const char* func);
- size_t count_impl(const void* k1, DB_TXN* txn, const char* func);
- bool insert_impl(const void* k1, const void* d, DB_TXN* txn, const char* func);
- bool replace_impl(const void* k1, const void* d, DB_TXN* txn, const char* func);
- bool remove_impl(const void* k1, const void* k2, DB_TXN* txn, const char* func);
- bool remove_impl(const void* k1, DB_TXN* txn, const char* func);
- void clear_impl(DB_TXN* txn, const char* func);
- void flush_impl(const char* func);
- };
- template<class Data>
- struct kmapdset_select_key2
- {
- typedef typename Data::key_type type;
- };
- template<class Key2, class NonKeyData>
- struct kmapdset_select_key2<std::pair<Key2, NonKeyData> >
- {
- typedef Key2 type;
- };
- template<class Key1, class Key2, class Data, class Value, class Impl>
- class kmapdset_iterator :
- public std::iterator<std::bidirectional_iterator_tag, Value, ptrdiff_t, const Value*, const Value&>
- {
- boost::intrusive_ptr<Impl> m_impl;
- void copy_on_write()
- {
- if (m_impl->getRefCount() > 1)
- {
- Impl* p = new Impl(m_impl->m_owner);
- m_impl->m_ret = m_impl->m_curp->dup(m_impl->m_curp, &p->m_curp, DB_POSITION);
- FEBIRD_RT_assert(0 == m_impl->m_ret, std::runtime_error);
- m_impl.reset(p);
- }
- }
- private:
- #ifdef _MSC_VER
- //# pragma warning(disable: 4661) // declaration but not definition
- //! MSVC will warning C4661 "declaration but not definition"
- void operator++(int) { assert(0); }
- void operator--(int) { assert(0); }
- #else
- //! disable, because clone iterator will cause very much time and resource
- void operator++(int);// { assert(0); }
- void operator--(int);// { assert(0); }
- #endif
- public:
- kmapdset_iterator() {}
- explicit kmapdset_iterator(kmapdset_iterator_impl_base* impl)
- : m_impl(static_cast<Impl*>(impl))
- {
- assert(impl);
- assert(dynamic_cast<Impl*>(impl));
- }
- // bool exist() const { return DB_NOTFOUND != m_impl->m_ret && DB_KEYEMPTY != m_impl->m_ret; }
- bool exist() const { return 0 == m_impl->m_ret; }
- // increment and get key/data-cnt
- bool next_key(size_t& cnt) { return m_impl->next_key(&cnt,BOOST_CURRENT_FUNCTION); }
- bool insert(const Data& d) { return m_impl->insert(&d,BOOST_CURRENT_FUNCTION); }
- bool update(const Data& d) { return m_impl->update(&d,BOOST_CURRENT_FUNCTION); }
- bool replace(const Data& d) { return m_impl->replace(&d,BOOST_CURRENT_FUNCTION); }
- bool remove() const { return m_impl->remove(BOOST_CURRENT_FUNCTION); }
- bool remove(const Key2& k2) const { return m_impl->remove(&k2,BOOST_CURRENT_FUNCTION); }
- kmapdset_iterator& operator++()
- {
- assert(0 == m_impl->m_ret);
- copy_on_write();
- m_impl->increment(BOOST_CURRENT_FUNCTION);
- return *this;
- }
- kmapdset_iterator& operator--()
- {
- assert(0 == m_impl->m_ret);
- copy_on_write();
- m_impl->decrement(BOOST_CURRENT_FUNCTION);
- return *this;
- }
- const Value& operator*() const
- {
- assert(0 == m_impl->m_ret);
- return m_impl->m_kdv;
- }
- const Value* operator->() const
- {
- assert(0 == m_impl->m_ret);
- return &m_impl->m_kdv;
- }
- Value& get_mutable() const
- {
- assert(0 == m_impl->m_ret);
- return m_impl->m_kdv;
- }
- };
- //! @param Data Key2 is embeded in Data
- template<class Key1, class Data>
- class kmapdset : protected kmapdset_base
- {
- DECLARE_NONE_COPYABLE_CLASS(kmapdset)
- public:
- typedef Key1
- key1_t, key_type;
- typedef typename kmapdset_select_key2<Data>::type
- key2_t;
- typedef Data
- data_type, data_t;
- typedef std::pair<Key1, std::vector<Data> >
- value_type;
- typedef std::vector<Data>
- data_vec_t;
- typedef typename std::vector<Data>::const_iterator
- data_iter_t;
- protected:
- class kmapdset_iterator_impl : public kmapdset_iterator_impl_base
- {
- public:
- value_type m_kdv;
- kmapdset_iterator_impl(kmapdset_base* owner)
- : kmapdset_iterator_impl_base(owner)
- {}
- virtual void clear_vec()
- {
- m_kdv.second.resize(0);
- }
- virtual void push_back(void* data, size_t size)
- {
- Data x;
- PortableDataInput<MinMemIO> iData;
- iData.set(data);
- iData >> x;
- FEBIRD_RT_assert(iData.diff(data) == size, std::logic_error);
- m_kdv.second.push_back(x);
- }
- virtual void load_key1(void* data, size_t size)
- {
- PortableDataInput<MemIO> iKey1;
- iKey1.set(data, size);
- iKey1 >> m_kdv.first;
- FEBIRD_RT_assert(iKey1.diff(data) == size, std::logic_error);
- }
- virtual void save_key1(PortableDataOutput<AutoGrownMemIO>& oKey1)
- {
- oKey1 << m_kdv.first;
- }
- };
- //! overrides
- void save_key1(PortableDataOutput<AutoGrownMemIO>& dio, const void* key1) const { dio << *(const key1_t*)key1; }
- void save_key2(PortableDataOutput<AutoGrownMemIO>& dio, const void* key2) const { dio << *(const key2_t*)key2; }
- void save_data(PortableDataOutput<AutoGrownMemIO>& dio, const void* data) const { dio << *(const data_t*)data; }
- kmapdset_iterator_impl_base* make_iter() { return new kmapdset_iterator_impl(this); }
- public:
- typedef kmapdset_iterator<Key1, key2_t, Data, value_type, kmapdset_iterator_impl>
- iterator, const_iterator;
- kmapdset(DB_ENV* env, const char* dbname
- , DB_TXN* txn = NULL
- , bt_compare_fcn_type bt_comp = bdb_auto_bt_compare((key1_t*)(0))
- , bt_compare_fcn_type dup_comp = bdb_auto_bt_compare((key2_t*)(0))
- )
- : kmapdset_base(env, dbname, txn, bt_comp, dup_comp, BOOST_CURRENT_FUNCTION)
- {
- }
- kmapdset(DbEnv* env, const char* dbname
- , DbTxn* txn = NULL
- , bt_compare_fcn_type bt_comp = bdb_auto_bt_compare((key1_t*)(0))
- , bt_compare_fcn_type dup_comp = bdb_auto_bt_compare((key2_t*)(0))
- )
- : kmapdset_base(env->get_DB_ENV(), dbname, txn ? txn->get_DB_TXN() : NULL, bt_comp, dup_comp, BOOST_CURRENT_FUNCTION)
- {
- }
- iterator begin(DB_TXN* txn = NULL) { return iterator(begin_impl(txn, BOOST_CURRENT_FUNCTION)); }
- iterator end (DB_TXN* txn = NULL) { return iterator(end_impl (txn, BOOST_CURRENT_FUNCTION)); }
- iterator begin(DbTxn* txn) { return iterator(begin_impl(txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION)); }
- iterator end (DbTxn* txn) { return iterator(end_impl (txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION)); }
- iterator find(const Key1& k1, DB_TXN* txn = NULL)
- {
- return iterator(find_impl(&k1, txn, DB_SET|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
- }
- iterator find(const Key1& k1, DbTxn* txn)
- {
- return iterator(find_impl(&k1, txn->get_DB_TXN(), DB_SET|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
- }
- iterator find(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
- {
- return iterator(find_impl(&k1, &k2, txn, false, BOOST_CURRENT_FUNCTION));
- }
- iterator find(const Key1& k1, const key2_t& k2, DbTxn* txn)
- {
- return iterator(find_impl(&k1, &k2, txn->get_DB_TXN(), false, BOOST_CURRENT_FUNCTION));
- }
- iterator find_md(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
- {
- return iterator(find_impl(&k1, &k2, txn, true, BOOST_CURRENT_FUNCTION));
- }
- iterator find_md(const Key1& k1, const key2_t& k2, DbTxn* txn)
- {
- return iterator(find_impl(&k1, &k2, txn->get_DB_TXN(), true, BOOST_CURRENT_FUNCTION));
- }
- iterator lower_bound(const Key1& k1, DB_TXN* txn = NULL)
- {
- return iterator(find_impl(&k1, txn, DB_SET_RANGE|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
- }
- iterator lower_bound(const Key1& k1, DbTxn* txn)
- {
- return iterator(find_impl(&k1, txn->get_DB_TXN(), DB_SET_RANGE|DB_MULTIPLE, BOOST_CURRENT_FUNCTION));
- }
- iterator upper_bound(const Key1& k1, DB_TXN* txn = NULL)
- {
- return iterator(upper_bound_impl(&k1, txn, BOOST_CURRENT_FUNCTION));
- }
- bool insert(const Key1& k1, const Data& d, DB_TXN* txn = NULL)
- {
- return insert_impl(&k1, &d, txn, BOOST_CURRENT_FUNCTION);
- }
- bool insert(const Key1& k1, const Data& d, DbTxn* txn)
- {
- return insert_impl(&k1, &d, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
- }
- bool replace(const Key1& k1, const Data& d, DB_TXN* txn = NULL)
- {
- return replace_impl(&k1, &d, txn, BOOST_CURRENT_FUNCTION);
- }
- bool replace(const Key1& k1, const Data& d, DbTxn* txn)
- {
- return replace_impl(&k1, &d, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
- }
- bool remove(const Key1& k1, const key2_t& k2, DB_TXN* txn = NULL)
- {
- return remove_impl(&k1, &k2, txn, BOOST_CURRENT_FUNCTION);
- }
- bool remove(const Key1& k1, const key2_t& k2, DbTxn* txn)
- {
- return remove_impl(&k1, &k2, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
- }
- bool remove(const Key1& k1, DB_TXN* txn = NULL)
- {
- return remove_impl(&k1, txn, BOOST_CURRENT_FUNCTION);
- }
- bool remove(const Key1& k1, DbTxn* txn)
- {
- return remove_impl(&k1, txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
- }
- bool erase(const iterator& iter)
- {
- return iter.remove();
- }
- void clear(DB_TXN* txn = NULL)
- {
- clear_impl(txn, BOOST_CURRENT_FUNCTION);
- }
- void clear(DbTxn* txn)
- {
- return clear_impl(txn->get_DB_TXN(), BOOST_CURRENT_FUNCTION);
- }
- void flush()
- {
- return flush_impl(BOOST_CURRENT_FUNCTION);
- }
- size_t count(const Key1& k1, DB_TXN* txn = NULL)
- {
- return count_impl(&k1, txn, BOOST_CURRENT_FUNCTION);
- }
- size_t count(const Key1& k1, DbTxn* txn)
- {
- return count_impl(&k1, txn ? txn->get_DB_TXN() : NULL, BOOST_CURRENT_FUNCTION);
- }
- DB* getDB() { return m_db; }
- const DB* getDB() const { return m_db; }
- };
- } // namespace febird
- #endif // __febird_bdb_kmapdset_h__
- /* vim: set tabstop=4 : */
- #include "kmapdset.h"
- //#include "../DataBuffer.h"
- #include <sstream>
- namespace febird {
- kmapdset_iterator_impl_base::kmapdset_iterator_impl_base(class kmapdset_base* owner)
- : m_owner(owner)
- , m_curp(0), m_ret(-1)
- {
- memset(&m_bulk, 0, sizeof(DBT));
- m_bulk.size = (owner->m_bulkSize);
- m_bulk.data = (::malloc(owner->m_bulkSize));
- m_bulk.flags = (DB_DBT_USERMEM);
- m_bulk.ulen = (owner->m_bulkSize);
- }
- void kmapdset_iterator_impl_base::init(DB* dbp, DB_TXN* txn, const char* func)
- {
- int ret = dbp->cursor(dbp, txn, &m_curp, 0);
- if (0 != ret)
- {
- delete this;
- std::ostringstream oss;
- oss << db_strerror(ret) << "... at: " << func;
- throw std::runtime_error(oss.str());
- }
- m_ret = 0;
- }
- kmapdset_iterator_impl_base::~kmapdset_iterator_impl_base()
- {
- if (m_bulk.data)
- ::free(m_bulk.data);
- if (m_curp)
- m_curp->close(m_curp);
- }
- bool kmapdset_iterator_impl_base::next_key(size_t* cnt, const char* func)
- {
- FEBIRD_RT_assert(0 == m_ret, std::logic_error);
- DBT tk1; memset(&tk1, 0, sizeof(DBT));
- m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_NEXT_NODUP);
- if (0 == m_ret)
- {
- load_key1(tk1.data, tk1.size);
- db_recno_t cnt0 = 0;
- int ret = m_curp->count(m_curp, &cnt0, 0);
- if (0 != ret)
- {
- std::ostringstream oss;
- oss << db_strerror(ret) << "... at: " << func;
- throw std::runtime_error(oss.str());
- }
- *cnt = cnt0;
- return true;
- }
- else if (DB_NOTFOUND == m_ret)
- {
- return false;
- }
- else
- {
- std::ostringstream oss;
- oss << db_strerror(m_ret) << "... at: " << func;
- throw std::runtime_error(oss.str());
- }
- }
- void kmapdset_iterator_impl_base::bulk_load(DBT* tk1)
- {
- FEBIRD_RT_assert(0 == m_ret, std::logic_error);
- load_key1(tk1->data, tk1->size);
- clear_vec();
- int ret;
- do {
- void *bptr, *data;
- size_t size;
- DB_MULTIPLE_INIT(bptr, &m_bulk);
- assert(NULL != bptr);
- for (;;)
- {
- DB_MULTIPLE_NEXT(bptr, &m_bulk, data, size);
- if (bptr)
- this->push_back(data, size);
- else
- break;
- }
- ret = m_curp->get(m_curp, tk1, &m_bulk, DB_MULTIPLE|DB_NEXT_DUP);
- } while (0 == ret);
- }
- void kmapdset_iterator_impl_base::increment(const char* func)
- {
- FEBIRD_RT_assert(0 == m_ret, std::logic_error);
- DBT tk1; memset(&tk1, 0, sizeof(DBT));
- m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_NEXT_NODUP|DB_MULTIPLE);
- if (0 == m_ret)
- {
- bulk_load(&tk1);
- }
- else if (DB_NOTFOUND != m_ret)
- {
- std::ostringstream oss;
- oss << db_strerror(m_ret) << "... at: " << func;
- throw std::runtime_error(oss.str());
- }
- }
- void kmapdset_iterator_impl_base::decrement(const char* func)
- {
- FEBIRD_RT_assert(0 == m_ret, std::logic_error);
- DBT tk1; memset(&tk1, 0, sizeof(DBT));
- m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_PREV_NODUP);
- if (0 == m_ret)
- {
- m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_CURRENT|DB_MULTIPLE);
- if (0 == m_ret)
- {
- bulk_load(&tk1);
- }
- else if (DB_KEYEMPTY == m_ret)
- {
- std::ostringstream oss;
- oss << db_strerror(m_ret)
- << "... at: " << func;
- throw std::runtime_error(oss.str());
- }
- }
- else if (DB_NOTFOUND != m_ret)
- {
- std::ostringstream oss;
- oss << db_strerror(m_ret) << "... at: " << func;
- throw std::runtime_error(oss.str());
- }
- }
- bool kmapdset_iterator_impl_base::find_pos(const void* k1, const void* k2, bool bulk, const char* func)
- {
- PortableDataOutput<AutoGrownMemIO> oKey1, oKey2;
- m_owner->save_key1(oKey1, k1);
- m_owner->save_key2(oKey2, k2);
- DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
- DBT tk2; memset(&tk2, 0, sizeof(DBT)); tk2.data = oKey2.begin(); tk2.size = oKey2.tell();
- m_ret = m_curp->get(m_curp, &tk1, &tk2, DB_GET_BOTH);
- if (0 == m_ret)
- {
- if (bulk) {
- m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_CURRENT|DB_MULTIPLE);
- if (0 == m_ret) {
- bulk_load(&tk1);
- return true;
- }
- } else {
- clear_vec();
- load_key1(tk1.data, tk1.size);
- push_back(tk2.data, tk2.size);
- return true;
- }
- }
- else if (DB_NOTFOUND == m_ret)
- {
- return false;
- }
- std::ostringstream oss;
- oss << db_strerror(m_ret)
- << "... at: " << func
- << "\n"
- ;
- throw std::runtime_error(oss.str());
- }
- /**
- @brief
- @return true successful inserted
- false fail, (key1, d) existed, and not inserted
- @throw other errors
- */
- bool kmapdset_iterator_impl_base::insert(const void* d, const char* func)
- {
- FEBIRD_RT_assert(0 == m_ret || DB_NOTFOUND == m_ret || DB_KEYEXIST == m_ret, std::logic_error);
- PortableDataOutput<AutoGrownMemIO> oKey1, oData;
- this->save_key1(oKey1);
- m_owner->save_data(oData, d);
- DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
- DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
- int ret = m_curp->put(m_curp, &tk1, &tdd, DB_NODUPDATA);
- if (DB_KEYEXIST == ret)
- return false;
- if (0 == ret)
- return true;
- std::ostringstream oss;
- oss << db_strerror(m_ret)
- << "... at: " << func;
- throw std::runtime_error(oss.str());
- }
- /**
- @brief
- @return true successful updated
- false (key1, d.key2) did not exist, not updated
- @throw other errors
- */
- bool kmapdset_iterator_impl_base::update(const void* d, const char* func)
- {
- FEBIRD_RT_assert(0 == m_ret, std::logic_error);
- PortableDataOutput<AutoGrownMemIO> oKey1, oData;
- this->save_key1(oKey1);
- m_owner->save_data(oData, d);
- DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
- DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
- int ret = m_curp->get(m_curp, &tk1, &tdd, DB_GET_BOTH);
- if (0 == ret)
- {
- tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
- tdd.data = oData.begin(); tdd.size = oData.tell();
- ret = m_curp->put(m_curp, &tk1, &tdd, DB_CURRENT);
- if (0 == ret)
- return true;
- }
- else if (DB_NOTFOUND == ret)
- {
- return false;
- }
- std::ostringstream oss;
- oss << db_strerror(ret)
- << "... at: " << func;
- throw std::runtime_error(oss.str());
- }
- /**
- @brief
- @return true item was replaced by (key1,d)
- false item was inserted
- @throw other errors
- */
- bool kmapdset_iterator_impl_base::replace(const void* d, const char* func)
- {
- PortableDataOutput<AutoGrownMemIO> oKey1, oData;
- this->save_key1(oKey1);
- m_owner->save_data(oData, d);
- DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
- DBT tdd; memset(&tdd, 0, sizeof(DBT)); tdd.data = oData.begin(); tdd.size = oData.tell();
- int ret = m_curp->get(m_curp, &tk1, &tdd, DB_GET_BOTH);
- if (0 == ret)
发表评论
-
检查序列化声明的顺序和成员定义的顺序
2009-04-11 16:12 1256项目地址:http://code.google.com/p/f ... -
febird.dataio 序列化宏
2009-04-08 11:23 1028序列化宏 DATA_IO_LOAD_SAVE( ... -
最便捷、最强大、速度最快的C++序列化框架
2008-11-07 18:08 2069最便捷、最强大、速度最快的C++序列化框架。 特别注意 ... -
持久化的 map ,使用 BerkeleyDB
2008-11-07 18:14 1076项目地址:http://code.google.com/p/f ... -
序列化如何简洁地支持XML
2009-01-02 14:24 947目前该框架(DataIO)仅支持二进制。想起序列化支持只需要一 ... -
febird.dataio 优化技术
2009-04-04 12:45 1288优化技术主要有以下几点: 1. 优化的inl ... -
febird.dataio和boost.serialization性能对比
2009-04-06 20:07 1556和boost.serialization性能对比 运行 ... -
febird.dataio vs boost.serialization 运行性能对比
2009-04-06 20:09 1037代码表示的是数据格式,DATA_IO_LOAD_SAVE 在 ...
相关推荐
嵌入式数据库Berkeley DB Java Edition Berkeley DB的使用 使用Berkeley DB的一般步骤 创建、打开、操作、关闭数据库环境Environment
berkeley db 使用手册
Berkeley DB4.8以上各版本,已经亲测过哪些版本可与redhat6.5兼容,见附件名称备注。
Berkeley db使用方法简介(c接口) 非SQL的高速内存数据库的使用方法,简单明了..
Oracle Berkeley DB Java 版是一个开源的、可嵌入的事务存储引擎,是完全用 Java 编写的。与 Oracle Berkeley DB 类似,Oracle Berkeley DB Java 版在应用程序的地址空间中执行,没有客户端/服务器通信的开销,从而...
Berkeley DB(BDB)是OpenLDAP后台数据库的默认配置,因此在安装OpenLDAP之前应先安装BDB。
多个进程,或者同一进程的多个线程可同时使用数据库,有如各自单独使用,底层的服务如加锁、事务日志、共享缓冲区管理、内存管理等等都由程序库透明地执行。 轻便灵活:可以运行于几乎所有的UNIX和Linux系统及其变种...
BerkeleyDB测试程序 包含散列文件入库,和读取的速度的测试
Berkeley DB文章集合
Berkeley DB 5.3.21.tar,你也可以去http://www.oracle.com/technetwork/products/berkeleydb/downloads/index.html下载最新版
BerkeleyDB的java应用jar包
Berkeley DB6.0.20 Berkeley DB BDB Berkeley DB数据库
Oracle BerkeleyDB-JE je-6.0.11
sqlite 和Berkeley db各方面 的比较
Java版本的Berkeley DB用户手册,找了好久
BerkeleyDB和Sqlite是当前最流行的嵌入式开源数据库。
本文描述了如何在Berkeley DB中使用事务(Transaction)。它简要介绍了事务是如何保护你的应用的数据的...本书假设你已经了解BerkeleyDB的基本架构知识(这些知识在<Getting Started with Berkeley DB Guide>一书中。)
介绍DB API的设置与使用的快速入门手册,目标是提供一个快速有效地机制,能让你进入Berkeley DB研发的世界。在本文中侧重于C++语言的研发人员,以及研究进城内数据管理解决方案的资深架构师。
不是所有的 SQL 应用程序都应该在 Oracle Berkeley DB 实施( Oracle Berkeley DB 是一个开放源的嵌入式数据库引擎,提供了快速、可靠、本地的持久性,无需管理),但如果您有一系列相对固定的查询且很关心性能,...