C++ (Cpp) dr_dm_manage_name Exemples

Exemple #1

 Cpe::Utils::CString const & name(void) const {
     return Cpe::Utils::CString::_cast(dr_dm_manage_name(*this));
 }

Exemple #2

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;
}