dr_dm_data_t dr_dm_data_find_by_id(dr_dm_manage_t mgr, dr_dm_data_id_t id) {
dr_dm_data_t key;
if (mgr->m_id_index == NULL) return NULL;
key = dr_dm_manage_key_buf(mgr);
if (dr_entry_set_from_uint64(
(char*)dr_dm_data_data(key) + dr_entry_data_start_pos(mgr->m_id_index->m_entry)
, id, mgr->m_id_index->m_entry, NULL) != 0)
return NULL;
return (dr_dm_data_t)cpe_hash_table_find(&mgr->m_id_index->m_roles, key);
}
dr_dm_data_t
dr_dm_data_find_by_index_ctype(dr_dm_manage_t mgr, const char * idx_name, const void * input, int input_type) {
struct dr_dm_data_index index_key;
struct dr_dm_data_index * index;
dr_dm_data_t key;
index_key.m_name = idx_name;
index = (struct dr_dm_data_index *)
cpe_hash_table_find(&mgr->m_indexes, &index_key);
if (index == NULL) return NULL;
key = dr_dm_manage_key_buf(mgr);
if (dr_entry_set_from_ctype(
dr_dm_data_data(key), input, input_type, index->m_entry, NULL) != 0)
{
return NULL;
}
return (dr_dm_data_t)cpe_hash_table_find(&index->m_roles, key);
}
T & createData(T const & input) {
Data & d = DataManager::createData(&input, sizeof(input));
return *(T*)dr_dm_data_data((dr_dm_data_t)&d);
}
T * createData(T const & input, const char ** duplicate_index) {
Data * d = DataManager::createData(&input, sizeof(input), duplicate_index);
return d ? (T*)dr_dm_data_data((dr_dm_data_t)d) : NULL;
}
T const * findData(dr_dm_data_id_t id) const {
Data const * d = DataManager::findData(id);
return d ? (T const *)dr_dm_data_data((dr_dm_data_t)d) : NULL;
}
T * findData(dr_dm_data_id_t id) {
Data * d = DataManager::findData(id);
return d ? (T*)dr_dm_data_data((dr_dm_data_t)d) : NULL;
}
T const * findData(const char * index, KeyT key) const {
Data const * d = DataManager::findData(index, key);
return d ? (T const *)dr_dm_data_data((dr_dm_data_t)d) : NULL;
}
dr_dm_data_t
dr_dm_data_create(dr_dm_manage_t mgr, const void * data, size_t data_size, const char ** duplicate_index) {
char * buf;
dr_dm_data_t role;
size_t data_capacity;
dr_dm_data_id_t role_id;
int generate_role_id;
size_t index_count;
struct cpe_hash_it index_it;
struct dr_dm_data_index * index;
size_t i;
index_count = cpe_hash_table_count(&mgr->m_indexes);
if (duplicate_index) *duplicate_index = NULL;
if (mgr->m_role_meta == NULL) {
CPE_ERROR(
mgr->m_em, "%s: dr_dm_data_create: role meta not exist!",
dr_dm_manage_name(mgr));
return NULL;
}
if (mgr->m_id_index == NULL) {
CPE_ERROR(
mgr->m_em, "%s: dr_dm_data_create: role id entry not exist!",
dr_dm_manage_name(mgr));
return NULL;
}
data_capacity = dr_meta_size(mgr->m_role_meta);
if (data_size > data_capacity) {
CPE_ERROR(
mgr->m_em, "%s: dr_dm_data_create: data too long, data_size=%d, data_capacity=%d!",
dr_dm_manage_name(mgr), (int)data_size, (int)data_capacity);
return NULL;
}
generate_role_id = 0;
role_id = dr_entry_read_int64(data, mgr->m_id_index->m_entry);
if (role_id == 0) {
if (mgr->m_id_generate) {
if (gd_id_generator_generate(&role_id, mgr->m_id_generate) != 0) {
CPE_ERROR(
mgr->m_em, "%s: dr_dm_data_create: generate id from %s fail!",
dr_dm_manage_name(mgr), gd_id_generator_name(mgr->m_id_generate));
return NULL;
}
else {
generate_role_id = 1;
}
}
}
buf = (char *)mem_alloc(
mgr->m_alloc,
sizeof(struct cpe_hash_entry) * index_count
+ sizeof(struct dr_dm_data)
+ data_capacity);
if (buf == NULL) return NULL;
role = (dr_dm_data_t)(buf + sizeof(struct cpe_hash_entry) * index_count);
role->m_mgr = mgr;
memcpy(dr_dm_data_data(role), data, data_capacity);
if (generate_role_id) {
if (dr_entry_set_from_int64(dr_dm_data_data(role), role_id, mgr->m_id_index->m_entry, NULL) != 0) {
CPE_ERROR(
mgr->m_em, "%s: dr_dm_data_create: set generated id to data fail!",
dr_dm_manage_name(mgr));
mem_free(mgr->m_alloc, buf);
return NULL;
}
}
for(i = 0; i < index_count; ++i) {
cpe_hash_entry_init(((struct cpe_hash_entry*)buf) + i);
}
cpe_hash_it_init(&index_it, &mgr->m_indexes);
while((index = cpe_hash_it_next(&index_it))) {
if (dr_dm_data_index_add(index, role) != 0) {
struct dr_dm_data_index * index_fall_back;
CPE_ERROR(
mgr->m_em, "%s: dr_dm_data_create: add to index %s: duplicate!",
dr_dm_manage_name(mgr), dr_entry_name(index->m_entry));
if (duplicate_index) *duplicate_index = dr_dm_data_index_name(index);
cpe_hash_it_init(&index_it, &mgr->m_indexes);
while((index_fall_back = cpe_hash_it_next(&index_it)) && index_fall_back != index) {
dr_dm_data_index_remove(index_fall_back, role);
}
mem_free(mgr->m_alloc, buf);
return NULL;
}
}
return role;
}
T const & as(void) const { return * (T*)dr_dm_data_data(*this); }
T & as(void) { return * (T*)dr_dm_data_data(*this); }
