void prune_tree(struct base_tree_node *n, int fasta_id)
{
if (n->A != NULL)
{
if (n->A->fasta_id < fasta_id)
{
remove_subtree(n->A);
n->A = NULL;
}
else
{
prune_tree(n->A, fasta_id);
}
}
if (n->C != NULL)
{
if (n->C->fasta_id < fasta_id)
{
remove_subtree(n->C);
n->C = NULL;
}
else
{
prune_tree(n->C, fasta_id);
}
}
if (n->G != NULL)
{
if (n->G->fasta_id < fasta_id)
{
remove_subtree(n->G);
n->G = NULL;
}
else
{
prune_tree(n->G, fasta_id);
}
}
if (n->T != NULL)
{
if (n->T->fasta_id < fasta_id)
{
remove_subtree(n->T);
n->T = NULL;
}
else
{
prune_tree(n->T, fasta_id);
}
}
}
static int
fco_invalidate(dev_info_t *ap, fco_handle_t rp, fc_ci_t *cp)
{
dev_info_t *root, *child;
struct fc_device_tree *subtree = fc_handle_to_dtree(rp);
int configured = (rp->cdip_state == FC_CDIP_CONFIG);
/*
* If we created any children, delete them. The root node is the
* config child, if one exists for this bus, otherwise it's the
* attachment point.
*
* Our copy of the subtree only contains records of nodes we created
* under the subtree root and contains the parent->child linkage
* that isn't yet established in the real device tree.
*
* XXX: What we don't do is restore the config child node to it's
* pre-interpretive state. (We may have added properties to
* that node. It's not clear if its necessary to clean them up.)
*/
root = rp->child ? rp->child : ap;
while ((child = fc_child_node(root, subtree)) != NULL) {
FC_DEBUG2(1, CE_CONT, "fco_invalidate: remove subtree "
"<%s> dip %p\n", ddi_node_name(child), child);
remove_subtree(child, subtree);
}
if (configured)
(void) ndi_devi_offline(root, NDI_UNCONFIG);
cp->nresults = fc_int2cell(0);
return (fc_success_op(ap, rp, cp));
}
void OIDTree::replace_subtree(OID root_oid, OIDMap update)
{
_map_lock.lock();
remove_subtree(root_oid);
_oidmap.insert(update.begin(), update.end());
_map_lock.unlock();
}
void remove_subtree(struct base_tree_node *n)
{
if (n->A != NULL)
{
remove_subtree(n->A);
}
if (n->C != NULL)
{
remove_subtree(n->C);
}
if (n->G != NULL)
{
remove_subtree(n->G);
}
if (n->T != NULL)
{
remove_subtree(n->T);
}
free_base_tree_node(n);
}
static void
remove_subtree(dev_info_t *root, struct fc_device_tree *subtree)
{
dev_info_t *child;
/*
* Remove the subtree, depth first. Each iterative
* call gets another child at each level of the tree
* until there are no more children.
*/
while ((child = fc_child_node(root, subtree)) != NULL)
remove_subtree(child, subtree);
/*
* Delete the subtree root and remove its record from our
* copy of the subtree.
*/
fc_remove_child(root, subtree);
(void) ndi_devi_offline(root, NDI_UNCONFIG | NDI_DEVI_REMOVE);
}
int main(void)
{
FILE *f = fopen("data", "r");
if (f == NULL)
{
puts("Failed to open data file");
return 1;
}
struct fasta_list fastas;
fastas.head = NULL;
fastas.current_node = NULL;
ssize_t chars_read;
char *current_line = NULL;
size_t current_line_alloc = 0;
while ((chars_read = getline(¤t_line, ¤t_line_alloc, f)) > -1)
{
//printf("READ FROM FILE: %s\n", current_line);
if (*current_line == '>')
{
// fasta name - skip '>' character
char *name = malloc((chars_read-1)*sizeof(char));
if (sscanf(current_line, ">%s\n", name) != 1)
{
puts("Failed to read line name");
return 1;
}
//printf("%s\n", name);
struct fasta_node *fn = new_fasta_node(name);
if (fastas.head == NULL)
{
// first entry
fastas.current_node = fastas.head = fn;
}
else if (fastas.current_node->fasta.dna.len == 0)
{
puts("Found title line but current fasta is empty");
return 1;
}
else
{
//printf("%s: %s", fastas.current_node->fasta.name, fastas.current_node->fasta.dna.data);
fastas.current_node = fastas.current_node->next = fn;
}
}
else
{
//printf("Adding chars to %s: %s", fastas.current_node->fasta.name, current_line);
if (current_line[chars_read] == '\0'
&& current_line[chars_read-1] == '\n')
{
current_line[chars_read-1] = '\0';
}
else
{
puts("Failed end of dna string newline replacement");
return 1;
}
append_chars(&(fastas.current_node->fasta.dna), current_line);
}
}
free(current_line);
fclose(f);
struct base_tree_node *base = new_base_tree_node("", "");
struct fasta_node *fn = fastas.head;
int fasta_id = 0;
while (fn != NULL)
{
//printf("%s\n%s\n", fn->fasta.name, fn->fasta.dna.data);
char *start = fn->fasta.dna.data;
while (*start != '\0')
{
//printf("next substring: %s\n", start);
suffix_tree_add(start, base, fasta_id);
start++;
}
prune_tree(base, fasta_id);
fn = fn->next;
fasta_id++;
}
char *longest = NULL;
int longest_level=-1;
find_longest_substring(base, 0, &longest, &longest_level);
printf("%s\n", longest);
remove_subtree(base);
free_fasta_nodes(&fastas);
}
