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);
}
}
}
static void remove_elem(GtDlistelem *elem, GtDlist *trees,
GtHashmap *target_to_elem, GtStr *key)
{
GtGenomeNode *node = gt_dlistelem_get_data(elem);
gt_genome_node_delete(node);
gt_dlist_remove(trees, elem);
gt_hashmap_remove(target_to_elem, gt_str_get(key));
}
void* gt_ranked_list_first(const GtRankedList *ranked_list)
{
/* return gt_rbtree_maximum_key(ranked_list->root); */
GtDlistelem *elem = gt_dlist_last(ranked_list->list);
if (elem != NULL)
return gt_dlistelem_get_data(elem);
else
return NULL;
}
static void targetbest_filter_stream_free(GtNodeStream *gs)
{
GtTargetbestFilterStream *tfs = targetbest_filter_stream_cast(gs);
for (; tfs->next != NULL; tfs->next = gt_dlistelem_next(tfs->next))
gt_genome_node_delete(gt_dlistelem_get_data(tfs->next));
gt_dlist_delete(tfs->trees);
gt_hashmap_delete(tfs->target_to_elem);
gt_node_stream_delete(tfs->in_stream);
}
void *gt_ranked_list_iter_prev(GtRankedListIter *ranked_list_iter)
{
/* return gt_rbtree_iter_next(ranked_list_iter); */
void *data = NULL;
if (ranked_list_iter->current_elem != NULL) {
data = gt_dlistelem_get_data(ranked_list_iter->current_elem);
ranked_list_iter->current_elem =
gt_dlistelem_next(ranked_list_iter->current_elem);
}
return data;
}
static void add_children_to_stack(GtArray *feature_stack,
const GtFeatureNode *fn)
{
GtFeatureNode *child;
GtDlistelem *dlistelem;
gt_assert(feature_stack && fn && fn->children);
/* add the children backwards to traverse in order */
for (dlistelem = gt_dlist_last(fn->children); dlistelem != NULL;
dlistelem = gt_dlistelem_previous(dlistelem)) {
child = gt_dlistelem_get_data(dlistelem);
gt_array_add(feature_stack, child);
}
}
GtDlistelem* gt_dlist_find(const GtDlist *dlist, void *new_data)
{
GtDlistelem *dlistelem;
void *old_data;
gt_assert(dlist);
for (dlistelem = gt_dlist_first(dlist); dlistelem != NULL;
dlistelem = gt_dlistelem_next(dlistelem)) {
old_data = gt_dlistelem_get_data(dlistelem);
if (dlist->cmp_func && !dlist->cmp_func(old_data, new_data))
return dlistelem;
else if (old_data == new_data)
return dlistelem;
}
return NULL;
}
void gt_ranked_list_delete(GtRankedList *ranked_list)
{
if (ranked_list == NULL) return;
/* gt_rbtree_delete(ranked_list->root); */
if (ranked_list->free_func != NULL) {
GtDlistelem *dlistelem;
for (dlistelem = gt_dlist_first(ranked_list->list); dlistelem != NULL;
dlistelem = gt_dlistelem_next(dlistelem)) {
void *data = gt_dlistelem_get_data(dlistelem);
ranked_list->free_func(data);
}
}
gt_dlist_delete(ranked_list->list);
gt_free(ranked_list);
}
static void feature_node_free(GtGenomeNode *gn)
{
GtFeatureNode *fn = gt_feature_node_cast(gn);
gt_str_delete(fn->seqid);
gt_str_delete(fn->source);
gt_tag_value_map_delete(fn->attributes);
if (fn->children) {
GtDlistelem *dlistelem;
for (dlistelem = gt_dlist_first(fn->children);
dlistelem != NULL;
dlistelem = gt_dlistelem_next(dlistelem)) {
gt_genome_node_delete(gt_dlistelem_get_data(dlistelem));
}
}
gt_dlist_delete(fn->children);
if (fn->observer && fn->observer->deleted)
fn->observer->deleted(fn, fn->observer->data);
if (fn->observer)
gt_feature_node_observer_delete(fn->observer);
}
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);
}
GtFeatureNodeIterator* gt_feature_node_iterator_new(const GtFeatureNode *fn)
{
GtFeatureNodeIterator *fni;
GtFeatureNode *child_feature;
GtDlistelem *dlistelem;
gt_assert(fn);
fni = feature_node_iterator_new_base(fn);
if (gt_feature_node_is_pseudo((GtFeatureNode*) fn)) {
/* add the children backwards to traverse in order */
for (dlistelem = gt_dlist_last(fn->children); dlistelem != NULL;
dlistelem = gt_dlistelem_previous(dlistelem)) {
child_feature = (GtFeatureNode*) gt_dlistelem_get_data(dlistelem);
gt_array_add(fni->feature_stack, child_feature);
}
}
else
gt_array_add(fni->feature_stack, fni->fn);
gt_assert(gt_array_size(fni->feature_stack));
fni->direct = false;
return fni;
}
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_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 gt_aligned_segments_pile_delete_finishing_before(
GtAlignedSegmentsPile *asp, unsigned long position)
{
GtDlistelem *dlistelem, *dlistelem_to_remove = NULL;
for (dlistelem = gt_dlist_first(asp->set); dlistelem != NULL;
dlistelem = gt_dlistelem_next(dlistelem))
{
GtAlignedSegment *as;
if (dlistelem_to_remove != NULL)
{
gt_dlist_remove(asp->set, dlistelem_to_remove);
dlistelem_to_remove = NULL;
}
as = gt_dlistelem_get_data(dlistelem);
if (gt_aligned_segment_refregion_endpos(as) < position)
{
if (asp->process_complete != NULL)
{
asp->process_complete(as, asp->process_complete_data);
}
if (asp->delete_processed_segments)
gt_aligned_segment_delete(as);
/* delay elem removal to avoid disrupting list traversal */
dlistelem_to_remove = dlistelem;
}
else
{
break;
}
}
if (dlistelem_to_remove != NULL)
{
gt_dlist_remove(asp->set, dlistelem_to_remove);
dlistelem_to_remove = NULL;
}
}
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;
}
