void rw_modify_hash_store() {
// open db
lmdb_hash_store_t hash_store(temp_dir, RW_MODIFY, 512, 0);
// exercise hash store interfaces
lmdb_hash_it_data_t hash_it_data;
hash_store.insert(binary_aa, 1, 2*4096, "");
hash_store.insert(binary_aa, 3, 4*4096, "");
hash_store.insert(binary_aa, 5, 6*4096, "");
hash_store.insert(binary_aa, 7, 8*4096, "");
hash_store.insert(binary_bb, 1, 2*4096, "");
hash_store.insert(binary_bb, 3, 4*4096, "");
hash_store.insert(binary_bb, 5, 6*4096, "");
hash_store.insert(binary_bb, 7, 8*4096, "");
hash_store.insert(binary_cc, 1, 2*4096, "");
hash_store.insert(binary_big, 1, 2*4096, "");
hash_store.insert(binary_big, 1, 42*4096, "");
TEST_EQ(hash_store.size(), 11);
TEST_EQ(hash_store.find(binary_aa, 1, 2*4096, ""), true);
TEST_EQ(hash_store.find(binary_aa, 9, 2*4096, ""), false);
TEST_EQ(hash_store.find(binary_aa, 1, 9*4096, ""), false);
TEST_EQ(hash_store.find(binary_cc, 1, 2*4096, ""), true);
TEST_EQ(hash_store.find_count(binary_aa), 4);
TEST_EQ(hash_store.find_count(binary_cc), 1);
hash_it_data = hash_store.find_first(binary_aa);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 1, 2*4096, "", true));
hash_store.find_begin();
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 1, 2*4096, "", true));
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 3, 4*4096, "", true));
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 5, 6*4096, "", true));
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 7, 8*4096, "", true));
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_bb, 1, 2*4096, "", true));
hash_it_data = hash_store.find_first(binary_cc);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_cc, 1, 2*4096, "", true));
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data.is_valid, false);
TEST_EQ(hash_store.erase(binary_aa, 3, 4*4096, ""), true);
TEST_EQ(hash_store.erase(binary_aa, 3, 4*4096, ""), false);
TEST_EQ(hash_store.size(), 10);
TEST_EQ(hash_store.erase(binary_big), 2);
TEST_EQ(hash_store.size(), 8);
// test hash_label
hash_store.insert(binary_aa, 1, 2*4096, "A"); // unique only in hash_label
hash_store.insert(binary_aa, 1, 10*4096, "B");
TEST_EQ(hash_store.size(), 10);
}
void rw_new() {
// clean up from any previous run
rm_hashdb_dir(temp_dir);
make_dir_if_not_there(temp_dir);
// create each db
lmdb_hash_store_t hash_store(temp_dir, RW_NEW, 512, 0);
lmdb_name_store_t name_store(temp_dir, RW_NEW);
lmdb_source_store_t source_store(temp_dir, RW_NEW);
}
Bool
apc_dbm_create( Handle self, Bool monochrome)
{
Bool palc = 0;
objCheck false;
apcErrClear;
apt_set( aptBitmap);
apt_set( aptDeviceBitmap);
apt_set( aptCompatiblePS);
if ( !( sys ps = CreateCompatibleDC( 0))) apiErrRet;
sys lastSize. x = var w;
sys lastSize. y = var h;
if ( monochrome)
sys bm = CreateBitmap( var w, var h, 1, 1, nil);
else {
HDC dc;
if (!( dc = dc_alloc())) {
DeleteDC( sys ps);
return false;
}
if (( sys pal = palette_create( self))) {
sys stockPalette = SelectPalette( sys ps, sys pal, 1);
RealizePalette( sys ps);
palc = 1;
}
sys bm = CreateCompatibleBitmap( dc, var w, var h);
if ( guts. displayBMInfo. bmiHeader. biBitCount == 8)
apt_clear( aptCompatiblePS);
}
if ( !sys bm) {
apiErr;
if ( !monochrome) dc_free();
if ( palc) {
SelectPalette( sys ps, sys stockPalette, 1);
DeleteObject( sys stockPalette);
sys stockPalette = nil;
}
DeleteDC( sys ps);
return false;
}
if ( !monochrome) dc_free();
sys stockBM = SelectObject( sys ps, sys bm);
hwnd_enter_paint( self);
if ( monochrome) sys bpp = 1;
hash_store( imageMan, &self, sizeof( self), (void*)self);
return true;
}
Bool
image_set_cache( Handle from, Handle self)
{
if ( sys pal == nil)
sys pal = image_make_bitmap_palette( from);
if ( sys bm == nil) {
sys bm = image_make_bitmap_handle( from, sys pal);
if ( sys bm == nil)
return false;
if ( !is_apt( aptDeviceBitmap))
hash_store( imageMan, &self, sizeof( self), (void*)self);
}
return true;
}
Bool
apc_application_create( Handle self)
{
XSetWindowAttributes attrs;
DEFXX;
if ( !DISP) {
Mdebug("apc_application_create: failed, x11 layer is not up\n");
return false;
}
XX-> type.application = true;
XX-> type.widget = true;
XX-> type.drawable = true;
attrs. event_mask = StructureNotifyMask | PropertyChangeMask;
XX-> client = X_WINDOW = XCreateWindow( DISP, guts. root,
0, 0, 1, 1, 0, CopyFromParent,
InputOutput, CopyFromParent,
CWEventMask, &attrs);
XCHECKPOINT;
if (!X_WINDOW) return false;
hash_store( guts.windows, &X_WINDOW, sizeof(X_WINDOW), (void*)self);
XX-> pointer_id = crArrow;
XX-> gdrawable = XX-> udrawable = guts. root;
XX-> parent = None;
XX-> origin. x = 0;
XX-> origin. y = 0;
XX-> ackSize = XX-> size = apc_application_get_size( self);
XX-> owner = nilHandle;
XX-> visual = &guts. visual;
XX-> flags. clip_owner = 1;
XX-> flags. sync_paint = 0;
apc_component_fullname_changed_notify( self);
guts. mouse_wheel_down = unix_rm_get_int( self, guts.qWheeldown, guts.qwheeldown, 5);
guts. mouse_wheel_up = unix_rm_get_int( self, guts.qWheelup, guts.qwheelup, 4);
guts. click_time_frame = unix_rm_get_int( self, guts.qClicktimeframe, guts.qclicktimeframe, guts. click_time_frame);
guts. double_click_time_frame = unix_rm_get_int( self, guts.qDoubleclicktimeframe, guts.qdoubleclicktimeframe, guts. double_click_time_frame);
guts. visible_timeout = unix_rm_get_int( self, guts.qBlinkvisibletime, guts.qblinkvisibletime, guts. visible_timeout);
guts. invisible_timeout = unix_rm_get_int( self, guts.qBlinkinvisibletime, guts.qblinkinvisibletime, guts. invisible_timeout);
guts. menu_timeout = unix_rm_get_int( self, guts.qSubmenudelay, guts.qsubmenudelay, guts. menu_timeout);
guts. scroll_first = unix_rm_get_int( self, guts.qScrollfirst, guts.qscrollfirst, guts. scroll_first);
guts. scroll_next = unix_rm_get_int( self, guts.qScrollnext, guts.qscrollnext, guts. scroll_next);
prima_send_create_event( X_WINDOW);
return true;
}
static layout_search_t *new_search(const char *search_ID)
{
layout_search_t *s;
layout_search_free(search_ID);
if (layout_searches == NULL) {
layout_searches = hash_create(64, gpmi_hash_ptr);
assert(layout_searches != NULL);
}
s = calloc(sizeof(layout_search_t), 1);
hash_store(layout_searches, search_ID, s);
return s;
}
void read_only_hash_store() {
// open db
lmdb_hash_store_t hash_store(temp_dir, READ_ONLY, 512, 0);
TEST_EQ(hash_store.size(), 10);
TEST_EQ(hash_store.find(binary_aa, 1, 2*4096, ""), true);
TEST_EQ(hash_store.find(binary_aa, 9, 2*4096, ""), false);
TEST_EQ(hash_store.find(binary_aa, 1, 9*4096, ""), false);
TEST_EQ(hash_store.find(binary_aa, 1, 10*4096, ""), false);
TEST_EQ(hash_store.find(binary_aa, 1, 10*4096, "A"), false);
TEST_EQ(hash_store.find(binary_aa, 1, 10*4096, "B"), true);
TEST_EQ(hash_store.find(binary_cc, 1, 2*4096, ""), true);
TEST_EQ(hash_store.find_count(binary_aa), 5);
TEST_EQ(hash_store.find_count(binary_cc), 1);
lmdb_hash_it_data_t hash_it_data;
hash_it_data = hash_store.find_first(binary_aa);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 1, 2*4096, "", true));
TEST_EQ(hash_store.find_begin(), hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 1, 2*4096, "", true));
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 1, 2*4096, "A", true));
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 1, 10*4096, "B", true));
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_aa, 5, 6*4096, "", true));
hash_it_data = hash_store.find_next(hash_it_data);
hash_it_data = hash_store.find_next(hash_it_data);
TEST_EQ(hash_it_data, lmdb_hash_it_data_t(binary_bb, 1, 2*4096, "", true));
// test hash_label
TEST_EQ(hash_store.find(binary_aa, 1, 2*4096, ""), true);
TEST_EQ(hash_store.find(binary_aa, 1, 2*4096, "A"), true);
TEST_EQ(hash_store.find(binary_aa, 1, 2*4096, "B"), false);
TEST_EQ(hash_store.find(binary_aa, 1, 10*4096, "A"), false);
TEST_EQ(hash_store.find(binary_aa, 1, 10*4096, "B"), true);
}
/* Write to DIGEST_PATH a representation of CHILDREN (which may be
empty, if the versioned path in FS represented by DIGEST_PATH has
no children) and LOCK (which may be NULL if that versioned path is
lock itself locked). Set the permissions of DIGEST_PATH to those of
PERMS_REFERENCE. Use POOL for all allocations.
*/
static svn_error_t *
write_digest_file(apr_hash_t *children,
svn_lock_t *lock,
const char *fs_path,
const char *digest_path,
const char *perms_reference,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
svn_stream_t *stream;
apr_hash_index_t *hi;
apr_hash_t *hash = apr_hash_make(pool);
const char *tmp_path;
SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_join(fs_path, PATH_LOCKS_DIR,
pool), fs_path, pool));
SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_dirname(digest_path, pool),
fs_path, pool));
if (lock)
{
const char *creation_date = NULL, *expiration_date = NULL;
if (lock->creation_date)
creation_date = svn_time_to_cstring(lock->creation_date, pool);
if (lock->expiration_date)
expiration_date = svn_time_to_cstring(lock->expiration_date, pool);
hash_store(hash, PATH_KEY, sizeof(PATH_KEY)-1,
lock->path, APR_HASH_KEY_STRING, pool);
hash_store(hash, TOKEN_KEY, sizeof(TOKEN_KEY)-1,
lock->token, APR_HASH_KEY_STRING, pool);
hash_store(hash, OWNER_KEY, sizeof(OWNER_KEY)-1,
lock->owner, APR_HASH_KEY_STRING, pool);
hash_store(hash, COMMENT_KEY, sizeof(COMMENT_KEY)-1,
lock->comment, APR_HASH_KEY_STRING, pool);
hash_store(hash, IS_DAV_COMMENT_KEY, sizeof(IS_DAV_COMMENT_KEY)-1,
lock->is_dav_comment ? "1" : "0", 1, pool);
hash_store(hash, CREATION_DATE_KEY, sizeof(CREATION_DATE_KEY)-1,
creation_date, APR_HASH_KEY_STRING, pool);
hash_store(hash, EXPIRATION_DATE_KEY, sizeof(EXPIRATION_DATE_KEY)-1,
expiration_date, APR_HASH_KEY_STRING, pool);
}
if (apr_hash_count(children))
{
svn_stringbuf_t *children_list = svn_stringbuf_create("", pool);
for (hi = apr_hash_first(pool, children); hi; hi = apr_hash_next(hi))
{
svn_stringbuf_appendbytes(children_list,
svn__apr_hash_index_key(hi),
svn__apr_hash_index_klen(hi));
svn_stringbuf_appendbyte(children_list, '\n');
}
hash_store(hash, CHILDREN_KEY, sizeof(CHILDREN_KEY)-1,
children_list->data, children_list->len, pool);
}
SVN_ERR(svn_stream_open_unique(&stream, &tmp_path,
svn_dirent_dirname(digest_path, pool),
svn_io_file_del_none, pool, pool));
if ((err = svn_hash_write2(hash, stream, SVN_HASH_TERMINATOR, pool)))
{
svn_error_clear(svn_stream_close(stream));
return svn_error_createf(err->apr_err,
err,
_("Cannot write lock/entries hashfile '%s'"),
svn_dirent_local_style(tmp_path, pool));
}
SVN_ERR(svn_stream_close(stream));
SVN_ERR(svn_io_file_rename(tmp_path, digest_path, pool));
SVN_ERR(svn_io_copy_perms(perms_reference, digest_path, pool));
return SVN_NO_ERROR;
}
