int
userlist_remove (struct session *sess, char *name)
{
struct User *user;
int pos;
user = userlist_find (sess, name);
if (!user)
return FALSE;
if (user->voice)
sess->voices--;
if (user->op)
sess->ops--;
if (user->hop)
sess->hops--;
sess->total--;
fe_userlist_numbers (sess);
fe_userlist_remove (sess, user);
if (user == sess->me)
sess->me = NULL;
tree_remove (sess->usertree, user, &pos);
tree_remove (sess->usertree_alpha, user, &pos);
free_user (user, NULL);
return TRUE;
}
void
userlist_update_mode (session * sess, char *name, char mode, char sign)
{
int access;
int offset = 0;
int level;
int pos;
char prefix;
struct User *user;
user = userlist_find (sess, name);
if (!user)
return;
/* remove from binary trees, before we loose track of it */
tree_remove (sess->usertree, user, &pos);
tree_remove (sess->usertree_alpha, user, &pos);
/* which bit number is affected? */
access = mode_access (sess->server, mode, &prefix);
if (sign == '+')
{
level = TRUE;
if (!(user->access & (1 << access)))
{
offset = 1;
user->access |= (1 << access);
}
}
else
{
level = FALSE;
if (user->access & (1 << access))
{
offset = -1;
user->access &= ~(1 << access);
}
}
/* now what is this users highest prefix? e.g. @ for ops */
user->prefix[0] = get_nick_prefix (sess->server, user->access);
/* update the various counts using the CHANGED prefix only */
update_counts (sess, user, prefix, level, offset);
/* insert it back into its new place */
tree_insert (sess->usertree_alpha, user);
pos = tree_insert (sess->usertree, user);
/* let GTK move it too */
fe_userlist_move (sess, user, pos);
fe_userlist_numbers (sess);
}
static void
nodeRemove(tree_t *aTree, node_t *aNode, unsigned aNNodes) {
node_t *sNode;
#ifdef VERBOSE
fprintf(stderr, "trp_remove(%3ld)", aNode->key);
#endif
tree_remove(aTree, aNode);
/* Test trp_nsearch(). */
sNode = tree_nsearch(aTree, aNode);
assert(sNode == NULL || sNode->key >= aNode->key);
/* Test trp_psearch(). */
sNode = tree_psearch(aTree, aNode);
assert(sNode == NULL || sNode->key <= aNode->key);
aNode->magic = 0;
#ifdef TREE_PRINT
fprintf(stderr, "\n\t tree: ");
#endif
#ifdef FORWARD_PRINT
fprintf(stderr, "\n\tforward: ");
#endif
assert(aNNodes - 1 == treeIterate(aTree));
#ifdef REVERSE_PRINT
fprintf(stderr, "\n\treverse: ");
#endif
assert(aNNodes - 1 == treeIterateReverse(aTree));
#ifdef VERBOSE
fprintf(stderr, "\n");
#endif
}
void auto_test_remove(int n, double results[], test_set *set) {
int to_remove = n/100, i, size = n+to_remove, success, j;
int *array = (int*)malloc(sizeof(int)*to_remove);
struct timespec begin, end;
results[0]=results[1]=results[2]=0;
printf("debug: n=%d; size=%d; results[2]=%f\n",n,size,results[2]);
for (i = 0; i < to_remove; i++)
array[i] = rand()%size;
for (i = 0; i < TESTS; ++i)
{
printf("test #%d\n",i);
//list
clock_gettime(CLOCK_REALTIME, &begin);
for (j = 0; j < to_remove/10; j++)
list_remove(set[i].list, array[j]);
clock_gettime(CLOCK_REALTIME, &end);
results[0] += timespec_to_miliseconds(&begin, &end);
//bst
clock_gettime(CLOCK_REALTIME, &begin);
for (j = 0; j < to_remove; j++)
tree_remove(&(set[i].bst), array[j], &success);
clock_gettime(CLOCK_REALTIME, &end);
results[1] += timespec_to_miliseconds(&begin, &end);
//avl
int size_cpy = size;
clock_gettime(CLOCK_REALTIME, &begin);
for (j = 0; j < to_remove; j++) {
tree_remove(&(set[i].avl), array[j], &success);
if(success == 1) size_cpy--;
}
tree_avl_rebuild(&(set[i].avl), size_cpy);
clock_gettime(CLOCK_REALTIME, &end);
results[2] += timespec_to_miliseconds(&begin, &end);
}
for (i = 0; i < 3; ++i)
{
results[i]/=TESTS;
}
free(array);
return;
}
void tree_remove_gprof2(tree_t *tree){
char buf[10];
for(int i = 100000; i>=0; --i){
sprintf(buf, "%d", i);
char *key = buf;
tree_remove(tree,key);
}
}
static void injectable_free(injectable_t * injectable) {
assert(injectable->references == 0);
info("Freed injectable %s.", str_injectable(injectable));
tree_remove(&injectables, injectable->id);
if (injectable_is_library(injectable)) {
tree_remove(&libraries, injectable->id);
} else {
tree_remove(&bindings, injectable->id);
}
if (injectable->builtin) {
/* built-in injectable, do not unload */
} else {
injfile_unload(injectable->injfile);
}
}
treenode_t* tree_remove(treenode_t **treenode, char *name){
if (*treenode == NULL){
return *treenode;
}
if(strcmp(name, itemname((*treenode)->item)) < 0){
(*treenode)->left = tree_remove(&(*treenode)->left, name);
}
if (strcmp(name, itemname((*treenode)->item)) > 0){
(*treenode)->right = tree_remove(&(*treenode)->right, name);
}
else if ((*treenode)->left == NULL && (*treenode)->right == NULL){
free(treenode);
}
/// Node has 1 child (right)
else if ((*treenode)->left == NULL) {
treenode_t *temp = (*treenode)->right;
free(*treenode);
return temp;
}
/// Node has 1 child (left)
else if ((*treenode)->right == NULL){
treenode_t*temp = (*treenode) ->left;
free(*treenode);
return temp;
}
// Find inorder successor
treenode_t *temp = inorder_successor((*treenode)->right, name);
//store inorder successor in node
(*treenode)->item = temp->item;
//delete the inorder successor
(*treenode)->right = tree_remove(&(*treenode)->right, itemname(temp->item));
return *treenode;
}
void
userlist_remove_user (struct session *sess, struct User *user)
{
int pos;
if (user->voice)
sess->voices--;
if (user->op)
sess->ops--;
if (user->hop)
sess->hops--;
sess->total--;
fe_userlist_numbers (sess);
fe_userlist_remove (sess, user);
if (user == sess->me)
sess->me = NULL;
tree_remove (sess->usertree, user, &pos);
tree_remove (sess->usertree_alpha, user, &pos);
free_user (user, NULL);
}
bool search_tree_remove(Search_tree *tree, int key, int *val)
{
Tree_node **node = get_node_ptr(tree, key);
if (*node == NULL)
return false;
if (val != NULL)
*val = (*node)->val;
tree_remove(node);
return true;
}
void clientei_remove(MainTreePt clientes){
unsigned int nif;
ClientePt tmp=NULL;
printf("NIF do cliente > ");
while( isUInt(nif = readUInt()) == 0 )
printf("Erro: NIF inválido.");
tmp = cliente_novo( nif, NULL, NULL, NULL );
tree_remove(clientes, tmp, 0);
free(tmp);
printf("Foi removido\n");
}
int
userlist_change (struct session *sess, char *oldname, char *newname)
{
struct User *user = userlist_find (sess, oldname);
int pos;
if (user)
{
tree_remove (sess->usertree, user, &pos);
tree_remove (sess->usertree_alpha, user, &pos);
safe_strcpy (user->nick, newname, NICKLEN);
tree_insert (sess->usertree_alpha, user);
fe_userlist_move (sess, user, tree_insert (sess->usertree, user));
fe_userlist_numbers (sess);
return 1;
}
return 0;
}
static void
nodeRemove(tree_t *aTree, node_t *aNode, unsigned aNNodes) {
node_t *sNode;
unsigned blackHeight, imbalances;
if (verbose) {
fprintf(stderr, "rb_remove(%3ld)", aNode->key);
}
tree_remove(aTree, aNode);
/* Test rb_nsearch(). */
sNode = tree_nsearch(aTree, aNode);
assert(sNode == NULL || sNode->key >= aNode->key);
/* Test rb_psearch(). */
sNode = tree_psearch(aTree, aNode);
assert(sNode == NULL || sNode->key <= aNode->key);
aNode->magic = 0;
if (tree_print) {
fprintf(stderr, "\n\t tree: ");
}
rbtn_black_height(node_t, link, aTree, blackHeight);
imbalances = treeRecurse(aTree->rbt_root, blackHeight, 0,
&(aTree->rbt_nil));
if (imbalances != 0) {
fprintf(stderr, "\nTree imbalance\n");
abort();
}
if (forward_print) {
fprintf(stderr, "\n\tforward: ");
}
assert(aNNodes - 1 == treeIterate(aTree));
if (reverse_print) {
fprintf(stderr, "\n\treverse: ");
}
assert(aNNodes - 1 == treeIterateReverse(aTree));
if (verbose) {
fprintf(stderr, "\n");
}
}
void camiaoi_remove(MainTreePt camiao){
char *input=NULL;
int tmpi;
CamiaoPt tmp=NULL;
printf("ID ou Matricula do camião > ");
lerStr( &input );
printf("Introduziu um ID (0) ou matricula (1)? > ");
while( isInt(tmpi = readInt()) == 0 && tmpi != 0 && tmpi != 1 )
printf("Erro: Valor inválido. Valores possíveis: 0 ou 1\n"); //erro
if( tmpi == 0 ){
tmp = camiao_novo( (int)strtol(input, NULL, 10), "", 0,0,NULL);
}else{
tmp = camiao_novo(0, input, 0,0,NULL);
}
tree_remove(camiao, tmp, tmpi);
free(tmp);
printf("Foi removido\n");
}
int
main(void) {
tree_t tree;
long set[NNODES];
node_t nodes[NNODES], key, *sNode;
unsigned i, j, k, l, m;
srandom(42);
for (i = 0; i < NSETS; i++) {
for (j = 0; j < NNODES; j++) {
set[j] = (long) (((double) NNODES)
* ((double) random() / ((double)RAND_MAX)));
}
for (j = 1; j <= NNODES; j++) {
#ifdef VERBOSE
fprintf(stderr, "Tree %u, %u node%s\n", i, j, j != 1 ? "s" : "");
#endif
/* Initialize tree and nodes. */
tree_new(&tree);
for (k = 0; k < j; k++) {
nodes[k].magic = NODE_MAGIC;
nodes[k].key = set[k];
}
/* Insert nodes. */
for (k = 0; k < j; k++) {
tree_insert(&tree, &nodes[k]);
for (l = 0; l < NSEARCH; l++) {
for (m = 0; m <= k; m++) {
sNode = tree_first(&tree);
sNode = tree_last(&tree);
key.key = nodes[m].key;
key.magic = NODE_MAGIC;
sNode = tree_search(&tree, &key);
sNode = tree_nsearch(&tree, &key);
}
}
}
for (k = 0; k < NITER; k++) {
treeIterate(&tree);
treeIterateReverse(&tree);
}
/* Remove nodes. */
for (k = 0; k < j; k++) {
for (l = 0; l < NSEARCH; l++) {
for (m = 0; m <= k; m++) {
sNode = tree_first(&tree);
sNode = tree_last(&tree);
key.key = nodes[m].key;
key.magic = NODE_MAGIC;
sNode = tree_search(&tree, &key);
sNode = tree_nsearch(&tree, &key);
}
}
tree_remove(&tree, &nodes[k]);
nodes[k].magic = 0;
}
}
}
return 0;
}
static int tree_scan_file(tree_t *tree, char *name, char *filename)
{
FILE *f;
char buf[BUFSIZ];
char *buf_dirname;
tree_item_t *save_current;
tree_object_t *obj;
tree_scan_data_t d;
int ret = 0;
/* Retrieve cannonical file name */
if ( (filename[0] == '.') && (filename[1] == G_DIR_SEPARATOR) )
filename += 2;
/* Open Tree definition file */
debug("SCAN TREE FILE %s\n", filename);
if ( (f = fopen(filename, "r")) == NULL )
return -1;
/* Save current node pointer */
save_current = tree->current;
/* Setup scan iterator */
d.tree = tree;
d.seq = NULL;
d.loc.filename = filename;
d.loc.lineno = 0;
d.dirname = buf_dirname = g_path_get_dirname(filename);
debug(">>>>> OPEN TREE FILE %s (dirname=%s)\n", d.loc.filename, d.dirname);
/* Create new SEQuence object */
obj = tree_object_new(TYPE_SEQ);
tree->current = tree_item_new(name, NULL, tree, obj, &(d.loc));
tree_add(tree, tree->current);
d.seq = obj->d.Seq;
/* If no sequence was defined before, assume it is the tree Tree Root */
if ( tree->head == NULL )
tree->head = tree->current;
/* Parse tree file */
while ( ! feof(f) ) {
if ( fgets(buf, BUFSIZ, f) != NULL ) {
char *str = g_strstrip(buf);
d.loc.lineno++;
if ( *str != '\0' )
tree_scan_line(&d, str);
}
}
free(buf_dirname);
fclose(f);
debug("<<<<< CLOSE TREE FILE %s\n", d.loc.filename);
/* Check branch emptyness */
if ( d.seq->nodes == NULL ) {
tree_warning(d.tree, &(d.loc), "SEQ '%s' ignored: branch file is empty", name);
tree_remove(tree, tree->current);
tree_item_destroy(tree->current);
tree_object_destroy(obj);
ret = -1;
}
/* Restore current node pointer */
tree->current = save_current;
return ret;
}
static void injection_free(injection_t * injection) {
tree_remove(&injection->process->injections, (tree_key_t) injection->injectable);
((injectable_t *) injection->injectable)->references--;
free(injection);
}
