Пример #1
0
GtRankedListIter *gt_ranked_list_iter_new_from_last(GtRankedList *ranked_list)
{
    /* return gt_rbtree_iter_new_from_first(ranked_list->root); */
    GtRankedListIter *iter = gt_calloc((size_t) 1, sizeof (*iter));
    iter->current_elem = gt_dlist_first(ranked_list->list);
    return iter;
}
Пример #2
0
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);
        }
    }
}
Пример #3
0
void* gt_ranked_list_last(const GtRankedList *ranked_list)
{
    /* return gt_rbtree_minimum_key(ranked_list->root); */
    GtDlistelem *elem = gt_dlist_first(ranked_list->list);
    if (elem != NULL)
        return gt_dlistelem_get_data(elem);
    else
        return NULL;
}
Пример #4
0
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;
}
Пример #5
0
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);
}
Пример #6
0
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 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;
}
Пример #8
0
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;
  }
}
Пример #10
0
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;
}