static void include_feature(GtDlist *trees, GtHashmap *target_to_elem,
GtFeatureNode *feature, GtStr *key)
{
gt_dlist_add(trees, feature);
gt_hashmap_add(target_to_elem, gt_cstr_dup(gt_str_get(key)),
gt_dlist_last(trees));
}
void gt_ranked_list_insert(GtRankedList *ranked_list, void *elem)
{
/* bool nodecreated = false; */
if (ranked_list->currentsize < ranked_list->maxsize)
{
if (ranked_list->currentsize == 0 ||
ranked_list->comparefunction(elem,ranked_list->worstelement,
ranked_list->compareinfo) < 0)
{
ranked_list->worstelement = elem;
}
/* (void) gt_rbtree_search(ranked_list->root, elem, &nodecreated); */
gt_dlist_add(ranked_list->list, elem);
/* if (nodecreated)
{ */
ranked_list->currentsize++;
/* } */
} else
{
/* new element is not as bad as worst element, so insert it and
and delete the worst element */
if (ranked_list->comparefunction(ranked_list->worstelement, elem,
ranked_list->compareinfo) <= 0)
{
GtDlistelem *oldelem = gt_dlist_first(ranked_list->list);
if (ranked_list->free_func != NULL)
ranked_list->free_func(gt_dlistelem_get_data(oldelem));
gt_dlist_remove(ranked_list->list, oldelem);
gt_dlist_add(ranked_list->list, elem);
ranked_list->worstelement =
gt_dlistelem_get_data(gt_dlist_first(ranked_list->list));
/* (void) gt_rbtree_search(ranked_list->root, elem, &nodecreated);
if (nodecreated)
{
if (gt_rbtree_erase(ranked_list->root, ranked_list->worstelement) != 0)
{
fprintf(stderr,"%s: deletion failed\n",__func__);
exit(GT_EXIT_PROGRAMMING_ERROR);
}
ranked_list->worstelement = gt_rbtree_minimum_key(ranked_list->root);
} */
} else if (ranked_list->free_func != NULL)
{
ranked_list->free_func(elem);
}
}
}
void gt_aligned_segments_pile_move_over_position(
GtAlignedSegmentsPile *asp, unsigned long position)
{
int retvalue;
if (asp->position != GT_UNDEF_ULONG)
{
gt_assert(position > asp->position);
gt_aligned_segments_pile_delete_finishing_before(asp, position);
}
while (true)
{
if (asp->next_as == NULL && !asp->all_consumed)
{
retvalue = gt_aligned_segments_pile_fetch_sa(asp);
if (retvalue == -1)
{
asp->all_consumed = true;
gt_assert(asp->next_as == NULL);
}
}
if (asp->next_as != NULL)
{
if (gt_aligned_segment_refregion_endpos(asp->next_as) < position)
{
if (asp->process_skipped != NULL)
{
asp->process_skipped(asp->next_as, asp->process_unmapped_data);
}
if (asp->delete_processed_segments)
gt_aligned_segment_delete(asp->next_as);
asp->next_as = NULL;
}
else
{
if (gt_aligned_segment_refregion_startpos(asp->next_as) <= position)
{
gt_dlist_add(asp->set, asp->next_as);
asp->next_as = NULL;
}
else
{
break;
}
}
}
else
{
break;
}
}
asp->position = position;
}
int gt_dlist_example(GT_UNUSED GtError *err)
{
GtDlistelem *dlistelem;
GtDlist *dlist;
void *data;
int elem = 1984;
gt_error_check(err);
dlist = gt_dlist_new(NULL);
gt_dlist_add(dlist, &elem);
gt_dlist_add(dlist, &elem);
gt_dlist_add(dlist, &elem);
/* a typical iterator loop */
for (dlistelem = gt_dlist_first(dlist); dlistelem != NULL;
dlistelem = gt_dlistelem_next(dlistelem)) {
data = gt_dlistelem_get_data(dlistelem);
/* do something with data */
}
gt_dlist_delete(dlist);
return 0;
}
static void filter_targetbest(GtFeatureNode *current_feature,
GtDlist *trees, GtHashmap *target_to_elem)
{
unsigned long num_of_targets;
GtDlistelem *previous_elem;
GtStr *first_target_id;
const char *target;
int had_err;
gt_assert(current_feature && trees);
target = gt_feature_node_get_attribute(current_feature, TARGET_STRING);
gt_assert(target);
first_target_id = gt_str_new();
had_err = gt_gff3_parser_parse_target_attributes(target, &num_of_targets,
first_target_id, NULL, NULL,
"", 0, NULL);
gt_assert(!had_err);
if (num_of_targets == 1) {
GtStr *key = gt_str_new();
build_key(key, current_feature, first_target_id);
if (!(previous_elem = gt_hashmap_get(target_to_elem, gt_str_get(key)))) {
/* element with this target_id not included yet -> include it */
include_feature(trees, target_to_elem, current_feature, key);
}
else {
GtFeatureNode *previous_feature = gt_dlistelem_get_data(previous_elem);
/* element with this target_id included already -> compare them */
if (gt_feature_node_get_score(current_feature) >
gt_feature_node_get_score(previous_feature)) {
/* current feature is better -> replace previous feature */
replace_previous_elem(previous_elem, current_feature, trees,
target_to_elem, key);
}
else /* current feature is not better -> remove it */
gt_genome_node_delete((GtGenomeNode*) current_feature);
}
gt_str_delete(key);
}
else
gt_dlist_add(trees, current_feature);
gt_str_delete(first_target_id);
}
static int targetbest_filter_stream_next(GtNodeStream *gs, GtGenomeNode **gn,
GtError *err)
{
GtTargetbestFilterStream *tfs;
GtGenomeNode *node;
int had_err = 0;
gt_error_check(err);
tfs = targetbest_filter_stream_cast(gs);
if (!tfs->in_stream_processed) {
while (!(had_err = gt_node_stream_next(tfs->in_stream, &node, err)) &&
node) {
if (gt_feature_node_try_cast(node) &&
gt_feature_node_get_attribute((GtFeatureNode*) node, "Target")) {
filter_targetbest((GtFeatureNode*) node, tfs->trees,
tfs->target_to_elem);
}
else
gt_dlist_add(tfs->trees, node);
}
tfs->next = gt_dlist_first(tfs->trees);
tfs->in_stream_processed = true;
}
if (!had_err) {
gt_assert(tfs->in_stream_processed);
if (tfs->next) {
*gn = gt_dlistelem_get_data(tfs->next);
tfs->next = gt_dlistelem_next(tfs->next);
}
else
*gn = NULL;
return 0;
}
return had_err;
}
int gt_dlist_unit_test(GtError *err)
{
GtDlist *dlist;
GtDlistelem *dlistelem;
int i, j, size, *data,
elem_a = 7,
elem_b = 6,
elems[MAX_SIZE],
elems_backup[MAX_SIZE],
had_err = 0;
gt_error_check(err);
/* boundary case: empty dlist */
dlist = gt_dlist_new(intcompare);
ensure(had_err, !gt_dlist_size(dlist));
gt_dlist_delete(dlist);
dlist = gt_dlist_new(NULL);
ensure(had_err, !gt_dlist_size(dlist));
gt_dlist_delete(dlist);
/* boundary case: dlist containing one element */
dlist = gt_dlist_new(intcompare);
gt_dlist_add(dlist, &elem_a);
ensure(had_err, gt_dlist_size(dlist) == 1);
ensure(had_err,
elem_a == *(int*) gt_dlistelem_get_data(gt_dlist_first(dlist)));
gt_dlist_delete(dlist);
dlist = gt_dlist_new(NULL);
gt_dlist_add(dlist, &elem_a);
ensure(had_err, gt_dlist_size(dlist) == 1);
ensure(had_err,
elem_a == *(int*) gt_dlistelem_get_data(gt_dlist_first(dlist)));
gt_dlist_delete(dlist);
/* boundary case: dlist containing two elements */
dlist = gt_dlist_new(intcompare);
gt_dlist_add(dlist, &elem_a);
gt_dlist_add(dlist, &elem_b);
ensure(had_err, gt_dlist_size(dlist) == 2);
ensure(had_err,
elem_b == *(int*) gt_dlistelem_get_data(gt_dlist_first(dlist)));
gt_dlist_delete(dlist);
dlist = gt_dlist_new(NULL);
gt_dlist_add(dlist, &elem_a);
gt_dlist_add(dlist, &elem_b);
ensure(had_err, gt_dlist_size(dlist) == 2);
ensure(had_err,
elem_a == *(int*) gt_dlistelem_get_data(gt_dlist_first(dlist)));
gt_dlist_delete(dlist);
for (i = 0; i < NUM_OF_TESTS && !had_err; i++) {
/* construct the random elements for the list */
size = gt_rand_max(MAX_SIZE);
for (j = 0; j < size; j++) {
elems[j] = gt_rand_max(INT_MAX);
elems_backup[j] = elems[j];
}
/* sort the backup elements */
qsort(elems_backup, size, sizeof (int), intcompare);
/* test with compare function */
dlist = gt_dlist_new(intcompare);
ensure(had_err, !gt_dlist_size(dlist));
for (j = 0; j < size && !had_err; j++) {
gt_dlist_add(dlist, elems + j);
ensure(had_err, gt_dlist_size(dlist) == j+1);
for (dlistelem = gt_dlist_first(dlist); dlistelem != NULL;
dlistelem = gt_dlistelem_next(dlistelem)) {
}
}
j = 0;
for (dlistelem = gt_dlist_first(dlist); dlistelem != NULL;
dlistelem = gt_dlistelem_next(dlistelem)) {
data = gt_dlistelem_get_data(dlistelem);
ensure(had_err, *data == elems_backup[j]);
j++;
}
/* test gt_dlist_find() */
for (j = 0; j < size; j++) {
dlistelem = gt_dlist_find(dlist, elems_backup + j);
ensure(had_err, dlistelem);
ensure(had_err,
*(int*) gt_dlistelem_get_data(dlistelem) == elems_backup[j]);
}
/* remove first element */
if (gt_dlist_size(dlist)) {
gt_dlist_remove(dlist, gt_dlist_first(dlist));
if (gt_dlist_size(dlist)) {
data = gt_dlistelem_get_data(gt_dlist_first(dlist));
ensure(had_err, *data == elems_backup[1]);
}
}
/* remove last element */
if (gt_dlist_size(dlist)) {
gt_dlist_remove(dlist, gt_dlist_last(dlist));
if (gt_dlist_size(dlist)) {
data = gt_dlistelem_get_data(gt_dlist_last(dlist));
ensure(had_err, *data == elems_backup[size - 2]);
}
}
/* XXX: fix this */
#if 0
/* remove middle element */
if (gt_dlist_size(dlist) >= 2) {
dlistelem = gt_dlist_first(dlist);
for (j = 1; j < gt_dlist_size(dlist) / 2; j++)
dlistelem = gt_dlistelem_next(dlistelem);
gt_dlist_remove(dlist, dlistelem);
dlistelem = gt_dlist_first(dlist);
for (j = 1; j < gt_dlist_size(dlist) / 2 + 1; j++)
dlistelem = gt_dlistelem_next(dlistelem);
data = gt_dlistelem_get_data(gt_dlist_last(dlist));
ensure(had_err, *data == elems_backup[size / 2 + 1]);
}
#endif
gt_dlist_delete(dlist);
/* test without compare function */
dlist = gt_dlist_new(NULL);
ensure(had_err, !gt_dlist_size(dlist));
for (j = 0; j < size && !had_err; j++) {
gt_dlist_add(dlist, elems + j);
ensure(had_err, gt_dlist_size(dlist) == j+1);
}
j = 0;
for (dlistelem = gt_dlist_first(dlist); dlistelem != NULL;
dlistelem = gt_dlistelem_next(dlistelem)) {
data = gt_dlistelem_get_data(dlistelem);
ensure(had_err, *data == elems[j]);
j++;
}
/* remove first element */
if (gt_dlist_size(dlist)) {
gt_dlist_remove(dlist, gt_dlist_first(dlist));
if (gt_dlist_size(dlist)) {
data = gt_dlistelem_get_data(gt_dlist_first(dlist));
ensure(had_err, *data == elems[1]);
}
}
/* remove last element */
if (gt_dlist_size(dlist)) {
gt_dlist_remove(dlist, gt_dlist_last(dlist));
if (gt_dlist_size(dlist)) {
data = gt_dlistelem_get_data(gt_dlist_last(dlist));
ensure(had_err, *data == elems[size - 2]);
}
}
gt_dlist_delete(dlist);
}
return had_err;
}
