コード例 #1
0
ファイル: networkd-route.c プロジェクト: Werkov/systemd
void route_free(Route *route) {
        if (!route)
                return;

        if (route->network) {
                LIST_REMOVE(routes, route->network->static_routes, route);

                assert(route->network->n_static_routes > 0);
                route->network->n_static_routes--;

                if (route->section)
                        hashmap_remove(route->network->routes_by_section, route->section);
        }

        network_config_section_free(route->section);

        if (route->link) {
                set_remove(route->link->routes, route);
                set_remove(route->link->routes_foreign, route);
        }

        sd_event_source_unref(route->expire);

        free(route);
}
コード例 #2
0
void routing_policy_rule_free(RoutingPolicyRule *rule) {

        if (!rule)
                return;

        if (rule->network) {
                LIST_REMOVE(rules, rule->network->rules, rule);
                assert(rule->network->n_rules > 0);
                rule->network->n_rules--;

                if (rule->section) {
                        hashmap_remove(rule->network->rules_by_section, rule->section);
                        network_config_section_free(rule->section);
                }

        }

        if (rule->manager) {
                set_remove(rule->manager->rules, rule);
                set_remove(rule->manager->rules_foreign, rule);
        }

        free(rule->iif);
        free(rule->oif);
        free(rule);
}
コード例 #3
0
ファイル: cube.c プロジェクト: SpectreV/HPowerEstimator
ace_cube_t * ace_cube_dup(ace_cube_t * cube) {
	int i;
	ace_cube_t * cube_copy;

	assert(cube != NULL);
	assert(cube->num_literals > 0);

	cube_copy = malloc(sizeof(ace_cube_t));
	cube_copy->static_prob = cube->static_prob;
	cube_copy->num_literals = cube->num_literals;
	cube_copy->cube = set_new (2 * cube->num_literals);
	for (i = 0; i < cube->num_literals; i++) {
		switch (node_get_literal (cube->cube, i)) {
		case ZERO:
			set_insert(cube_copy->cube, 2 * i);
			set_remove(cube_copy->cube, 2 * i + 1);
			break;
		case ONE:
			set_remove(cube_copy->cube, 2 * i);
			set_insert(cube_copy->cube, 2 * i + 1);
			break;
		case TWO:
			set_insert(cube_copy->cube, 2 * i);
			set_insert(cube_copy->cube, 2 * i + 1);
			break;
		default:
			fail("Bad literal.");
		}
	}

	return (cube_copy);
}
コード例 #4
0
int
main(int argc, char **argv)
{
	struct set *set;
	const char *str1 = "test1";
	const char *str2 = "test2";
	const char *str3 = "test3";

	set = set_create(badhash, string_key_equals);

	/* Unlike the hash table equivalent of this test, use an extra
	 * string so that the rehash happens at the right time.
	 */
	set_add(set, str1);
	set_add(set, str2);
	set_add(set, str3);
	set_remove(set, str2);
	set_add(set, str3);
	set_remove(set, str3);
	assert(!set_contains(set, str3));

	set_destroy(set, NULL);

	return 0;
}
コード例 #5
0
void makeflow_gc_prepare( struct dag *d )
{
	/* Files to be collected:
	 * ((all_files \minus sink_files)) \union collect_list) \minus preserve_list) \minus source_files
	 */

	/* Parse GC_*_LIST and record which target files should be
	 * garbage collected. */
	char *collect_list  = dag_variable_lookup_global_string("GC_COLLECT_LIST", d);
	char *preserve_list = dag_variable_lookup_global_string("GC_PRESERVE_LIST", d);

	struct dag_file *f;
	char *filename;

	/* add all files, but sink_files */
	hash_table_firstkey(d->files);
	while((hash_table_nextkey(d->files, &filename, (void **) &f)))
		if(!dag_file_is_sink(f)) {
			set_insert(d->collect_table, f);
		}

	int i, argc;
	char **argv;

	/* add collect_list, for sink_files that should be removed */
	string_split_quotes(collect_list, &argc, &argv);
	for(i = 0; i < argc; i++) {
		f = dag_file_lookup_or_create(d, argv[i]);
		set_insert(d->collect_table, f);
		debug(D_MAKEFLOW_RUN, "Added %s to garbage collection list", f->filename);
	}
	free(argv);

	/* remove files from preserve_list */
	string_split_quotes(preserve_list, &argc, &argv);
	for(i = 0; i < argc; i++) {
		/* Must initialize to non-zero for hash_table functions to work properly. */
		f = dag_file_lookup_or_create(d, argv[i]);
		set_remove(d->collect_table, f);
		debug(D_MAKEFLOW_RUN, "Removed %s from garbage collection list", f->filename);
	}
	free(argv);

	/* remove source_files from collect_table */
	hash_table_firstkey(d->files);
	while((hash_table_nextkey(d->files, &filename, (void **) &f)))
		if(dag_file_is_source(f)) {
			set_remove(d->collect_table, f);
			debug(D_MAKEFLOW_RUN, "Removed %s from garbage collection list", f->filename);
		}

	/* Print reference counts of files to be collected */
	set_first_element(d->collect_table);
	while((f = set_next_element(d->collect_table)))
		debug(D_MAKEFLOW_RUN, "Added %s to garbage collection list (%d)", f->filename, f->ref_count);
}
コード例 #6
0
ファイル: test-set.c プロジェクト: dlove24/dl-calg
void test_set_remove (void) {
  Set* set;
  char buf[10];
  int i;
  unsigned int num_entries;

  set = generate_set();

  num_entries = set_num_entries (set);
  assert (num_entries == 10000);

  /* Remove some entries */

  for (i = 4000; i < 6000; ++i) {

    sprintf (buf, "%i", i);

    /* Check this is in the set */

    assert (set_query (set, buf) != 0);

    /* Remove it */

    assert (set_remove (set, buf) != 0);

    /* Check the number of entries decreases */

    assert (set_num_entries (set) == num_entries - 1);

    /* Check it is no longer in the set */

    assert (set_query (set, buf) == 0);

    --num_entries;
    }

  /* Try to remove some invalid entries */

  for (i = -1000; i < -500; ++i) {
    sprintf (buf, "%i", i);

    assert (set_remove (set, buf) == 0);
    assert (set_num_entries (set) == num_entries);
    }

  for (i = 50000; i < 51000; ++i) {
    sprintf (buf, "%i", i);

    assert (set_remove (set, buf) == 0);
    assert (set_num_entries (set) == num_entries);
    }

  set_free (set);
  }
コード例 #7
0
ファイル: set.c プロジェクト: Zugamifk/fishermans
void
set_test()
{
	printf("SET S: ");
	set* s = set_init();
	set_add(s, (SETDATA*)1);
	set_add(s, (SETDATA*)2);
	set_add(s, (SETDATA*)3);
	set_add(s, (SETDATA*)4);
	set_add(s, (SETDATA*)5);
	set_add(s, (SETDATA*)6);
	set_print(s, set_testcb);

	printf("S \\ 2, 6: ");
	set_remove(s, (SETDATA*)6);
	set_remove(s, (SETDATA*)2);
	set_print(s, set_testcb);
	
	printf("SET T: ");
	set* t = set_init();
	set_add(t, (SETDATA*)1);
	set_add(t, (SETDATA*)2);
	set_add(t, (SETDATA*)9);
	set_add(t, (SETDATA*)4);
	set_print(t, set_testcb);
	
	printf("UNION OF S, T: ");
	set* u = set_init();
	set_union(u, s, t);
	set_print(u, set_testcb);
	
	printf("INTERSECTION OF S, T: ");
	set* i = set_init();
	set_intersection(i, s, t);
	set_print(i, set_testcb);
	
	printf("DIFFERENCE OF S, T: ");
	set* d = set_init();
	set_difference(d, s, t);
	set_print(d, set_testcb);
	
	printf("CLEAR S: ");
	set_clear(s);
	set_print(s, set_testcb);
	
	set_free(s);
	set_free(t);
	set_free(u);
	set_free(i);
	set_free(d);
}
コード例 #8
0
ファイル: cover.c プロジェクト: Andy-Shao/arithmetic_c
int cover(Set *members, Set *subsets, Set *covering){
    Set intersection;
    KSet *subset;
    ListElmt *member, *max_member;
    void *data;
    int max_size;

    //Initialize the covering.
    set_init(covering, subsets->match, NULL);

    //Continue while there are noncovered members and candidate subsets.
    while(set_size(members)>0 && set_size(subsets)>0){
        //Find the subset that covers the most members.
        max_size = 0;
        for(member=list_head(subsets); member!=NULL; member=list_next(member)){
            if(set_intersection(&intersection, &((KSet *)list_data(member))->set, members) != 0) return -1;

            if(set_size(&intersection)>max_size){
                max_member = member;
                max_size = set_size(&intersection);
            }

            set_destroy(&intersection);
        }

        //A covering is not possible if there was no intersection.
        if(max_size == 0) return 1;

        //Insert the selected subset into the covering.
        subset = (KSet *)list_data(max_member);

        if(set_insert(covering, subset) != 0) return -1;

        //Remove each covered member from the set of noncovered members.
        for(member=list_head(&((KSet *)list_data(max_member))->set); member!=NULL; member=list_next(member)){
            data = list_data(member);
            if(set_remove(members, (void**)&data)==0 && members->destroy!=NULL) members->destroy(data);
        }

        //Remove the subset from the set of candidate subsets.
        if(set_remove(subsets, (void **)&subset) != 0) return -1;
    }

    //No covering is possible if there are still noncovered members.
    if(set_size(members) > 0) return -1;

    return 0;
}
コード例 #9
0
ファイル: test-set.c プロジェクト: dlove24/dl-calg
void test_set_free_function (void) {
  Set* set;
  int i;
  int* value;

  /* Create a set and fill it with 1000 values */

  set = set_new (int_hash, int_equal);

  set_register_free_function (set, free_value);

  allocated_values = 0;

  for (i = 0; i < 1000; ++i) {
    value = new_value (i);

    set_insert (set, value);
    }

  assert (allocated_values == 1000);

  /* Test removing a value */

  i = 500;
  set_remove (set, &i);

  assert (allocated_values == 999);

  /* Test freeing the set */

  set_free (set);

  assert (allocated_values == 0);
  }
コード例 #10
0
ファイル: graph.c プロジェクト: whatot/ma_c
/* graph_rem_edge */
int graph_rem_edge(Graph *graph, void *data1, void **data2)
{
	ListElmt *element;

	/* LOcate the adjacency list for the first vertex. */
	for (element = list_head(&graph->adjlists); element != NULL; 
	     element = list_next(element)) {
		if (graph->match(data1, 
				 ((AdjList *)list_data(element))->vertex)) {
			break;
		}
	}

	if (element == NULL) {
		return -1;
	}

	/* Remove the second vertex from the adjacency list of the first vertex. */
	if (set_remove(&((AdjList *)list_data(element))->adjacent, data2) != 0) {
		return -1;
	}

	/* Adjust the edge count to account for the removed edge. */
	graph->ecount--;
	return 0;
} 
コード例 #11
0
ファイル: linkedlist.cpp プロジェクト: nmldiegues/proteustm
void *test(void *data)
{

  unsigned int mySeed = seed + sched_getcpu();

  long myOps = operations / nb_threads;
  long val = -1;
  int op;

  while (myOps > 0) {
    op = rand_r(&mySeed) % 100;
    if (op < update) {
      if (val == -1) {
        /* Add random value */  
        val = (rand_r(&mySeed) % range) + 1;
        if(set_add(val) == 0) {
          val = -1;
        }
      } else {
        /* Remove random value */
        int res = set_remove( val);
        val = -1;
      }
    } else {
      /* Look for random value */
      long tmp = (rand_r(&mySeed) % range) + 1;
      set_contains(tmp);
    }

    myOps--;
  }

  return NULL;
}
コード例 #12
0
ファイル: exoskeleton.c プロジェクト: ehershey/pd
void create() {
::create();
set_name("armor");
set_short("%^ORANGE%^E%^RESET%^BOLD%^WHITE%^x%^RESET%^ORANGE%^oskeleton%^RESET%^");
set_long("A strange creation of the ancient female raknids, these magical skeletons bond with the raknid's hardened shells providing its user with even greater protection.");
set_wear("The exoskeleton claps tightly around your body.");
set_remove("You release the magical bonds and remove your exoskeleton.");
set_id(({"armor", "armour", "exoskeleton"}));
コード例 #13
0
ファイル: darkmail.c プロジェクト: ehershey/pd
void create() {
::create();
set_name("armor");
set_short("%^RESET%^%^CYAN%^D%^BOLD%^%^BLACK%^ark%^RESET%^%^CYAN%^M%^BOLD%^%^BLACK%^ail%^RESET%^");
set_long("%^BOLD%^%^WHITE%^A gift from the Merkkirri queen to Samul, DarkMail armor is composed of swirling dark energy that encompasses the user perfectly.  The armors exact style and design are dependent upon the person wearing it as it is scuplted according to the users darkest fears.%^RESET%^");
set_wear("%^CYAN%^You will the %^BOLD%^%^BLACK%^dark%^RESET%^%^CYAN%^ energy to envelop you.%^RESET%^");
set_remove("%^CYAN%^You will the %^BOLD%^%^BLACK%^dark%^RESET%^%^CYAN%^ energy to release you from its protection.%^RESET%^");
set_id(({"armor", "armour", "darkmail", "Darkmail"}));
コード例 #14
0
void create() {
::create();
set_name("helm");
set_short("%^RESET%^BLUE%^Helm of %^BOLD%^BLACK%^sh%^RESET%^BLUE%^ad%^BOLD%^BLACK%^ows%^RESET%^");
set_long("%^RESET%^BLUE%^The helm of shadows is a four-horned warhelm made of a strange black metal.  It has a built in visor that is shaped to appear as the blackened skull of a gnoll.  The metal is light and gives ample ventilation--always a plus while travelling in the hot Merkkirri jungles.%^RESET%^");
set_wear("%^BLUE%^You wear the helm of shadows and lock the visor into place.%^RESET%^");
set_remove("%^BLUE%^You unlock the visor and remove the helm of shadows.%^RESET%^");
set_id(({"helm", "warhelm", "helm of shadows", "shadowhelm"}));
コード例 #15
0
ファイル: skull_bl.c プロジェクト: ehershey/pd
void create() {
::create();
set_name("bracer");
set_short("%^BOLD%^WHITE%^S%^BOLD%^BLACK%^kul%^BOLD%^WHITE%^l B%^BOLD%^BLACK%^race%^BOLD%^WHITE%^r%^RESET%^");
set_long("This bracer is made of black iron and has a screaming demonic skull etched into the side.");
set_wear("%^BOLD%^WHITE%^T%^BOLD%^BLACK%^he bracer makes your arm feel secur%^BOLD%^WHITE%^e%^RESET%^.");
set_remove("%^BOLD%^WHITE%^Y%^BOLD%^BLACK%^our arm feels more vunerabl%^BOLD%^WHITE%^e%^RESET%^.");
set_id(({"bracer", "skull bracer"}));
コード例 #16
0
ファイル: catalog_query.c プロジェクト: btovar/cctools
struct catalog_query *catalog_query_create(const char *hosts, struct jx *filter_expr, time_t stoptime)
{
	struct catalog_query *q = NULL;
	char *n;
	struct catalog_host *h;
	struct list *sorted_hosts = catalog_query_sort_hostlist(hosts);

	int backoff_interval = 1;

	list_first_item(sorted_hosts);
	while(time(NULL) < stoptime) {
		if(!(h = list_next_item(sorted_hosts))) {
			list_first_item(sorted_hosts);
			sleep(backoff_interval);

			int max_backoff_interval = MAX(0, stoptime - time(NULL));
			backoff_interval = MIN(backoff_interval * 2, max_backoff_interval);

			continue;
		}
		struct jx *j = catalog_query_send_query(h->url, time(NULL) + 5);

		if(j) {
			q = xxmalloc(sizeof(*q));
			q->data = j;
			q->current = j->u.items;
			q->filter_expr = filter_expr;

			if(h->down) {
				debug(D_DEBUG,"catalog server at %s is back up", h->host);
				set_first_element(down_hosts);
				while((n = set_next_element(down_hosts))) {
					if(!strcmp(n, h->host)) {
						free(n);
						set_remove(down_hosts, n);
						break;
					}
				}
			}
			break;
		} else {
			if(!h->down) {
				debug(D_DEBUG,"catalog server at %s seems to be down", h->host);
				set_insert(down_hosts, xxstrdup(h->host));
			}
		}
	}

	list_first_item(sorted_hosts);
	while((h = list_next_item(sorted_hosts))) {
		free(h->host);
		free(h->url);
		free(h);
	}
	list_delete(sorted_hosts);
	return q;
}
コード例 #17
0
ファイル: abcEspresso.c プロジェクト: Shubhankar007/ECEN-699
/**Function*************************************************************

  Synopsis    [Converts SOP in ABC into SOP representation in Espresso.]

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
pset_family Abc_SopToEspresso( char * pSop )
{
    char *      pCube;
    pset_family Cover;
    pset        set;
    int         nCubes, nVars, Value, v;
    
    if ( pSop == NULL ) 
        return NULL;
    
    nVars  = Abc_SopGetVarNum(pSop);
    nCubes = Abc_SopGetCubeNum(pSop);
    assert( cube.size == 2 * nVars );
    
    if ( Abc_SopIsConst0(pSop) ) 
    {
        Cover = sf_new(0, cube.size);
        return Cover;
    }
    if ( Abc_SopIsConst1(pSop) ) 
    {
        Cover = sf_new(1, cube.size);
        set = GETSET(Cover, Cover->count++);
        set_copy( set, cube.fullset );
        return Cover;
    }

    // create the cover
    Cover = sf_new(nCubes, cube.size);
    // fill in the cubes
    Abc_SopForEachCube( pSop, nVars, pCube )
    {
        set = GETSET(Cover, Cover->count++);
        set_copy( set, cube.fullset );
        Abc_CubeForEachVar( pCube, Value, v )
        {
            if ( Value == '0' )
                set_remove(set, 2*v+1);
            else if ( Value == '1' )
                set_remove(set, 2*v);
        }
    }
コード例 #18
0
ファイル: networkd-route.c プロジェクト: Cedric31/systemd
void route_free(Route *route) {
        if (!route)
                return;

        if (route->network) {
                LIST_REMOVE(routes, route->network->static_routes, route);

                if (route->section)
                        hashmap_remove(route->network->routes_by_section,
                                       UINT_TO_PTR(route->section));
        }

        if (route->link) {
                set_remove(route->link->routes, route);
                set_remove(route->link->routes_foreign, route);
        }

        sd_event_source_unref(route->expire);

        free(route);
}
コード例 #19
0
static int makeflow_gc_file( struct dag *d, const struct dag_file *f )
{
	struct stat buf;
	if(stat(f->filename, &buf) == 0 && unlink(f->filename)<0) {
		debug(D_NOTICE, "makeflow: unable to collect %s: %s", f->filename, strerror(errno));
		return 0;
	} else {
		debug(D_MAKEFLOW_RUN, "Garbage collected %s\n", f->filename);
		set_remove(d->collect_table, f);
		return 1;
	}
}
コード例 #20
0
ファイル: sc_usage.c プロジェクト: OpenDarwin-CVS/SEDarwin
void leave()			/* exit under normal conditions -- INT handler */
{

        if (no_screen_refresh == 0) {
	        move(LINES - 1, 0);
		refresh();
		endwin();
	}
	set_enable(0);
	set_pidcheck(pid, 0);
	set_remove();
	exit(0);
}
コード例 #21
0
ファイル: set.c プロジェクト: Baguage/cctools
void *set_pop(struct set *s)
{
  if( set_size(s) < 1 )
	return 0;

  void *element;
  set_first_element(s);
  element = set_next_element(s);

  if(!set_remove(s, element))
	return 0;
  else
	return element;
}
コード例 #22
0
int routing_policy_rule_make_local(Manager *m, RoutingPolicyRule *rule) {
        int r;

        assert(m);

        if (set_contains(m->rules_foreign, rule)) {
                set_remove(m->rules_foreign, rule);

                r = set_ensure_allocated(&m->rules, &routing_policy_rule_hash_ops);
                if (r < 0)
                        return r;

                return set_put(m->rules, rule);
        }

        return -ENOENT;
}
コード例 #23
0
ファイル: test_set.c プロジェクト: brunokim/cgraph
void test_removing(){
	set_t *set = new_set(0);
	
	int i;
	for (i=0; i < 1000; i++){ set_put(set, i); }
	assert(set_size(set) == 1000);
	
	set_optimize(set);
	
	for (i=0; i < 1000; i += 2){ set_remove(set, i); }
	assert(set_size(set) == 500);
	
	for (i=0; i < 1000; i += 2){ set_put(set, i); }
	assert(set_size(set) == 1000);
	
	delete_set(set);
}
コード例 #24
0
ファイル: socket-proxyd.c プロジェクト: ariscop/systemd
static void connection_free(Connection *c) {
        assert(c);

        if (c->context)
                set_remove(c->context->connections, c);

        sd_event_source_unref(c->server_event_source);
        sd_event_source_unref(c->client_event_source);

        if (c->server_fd >= 0)
                close_nointr_nofail(c->server_fd);
        if (c->client_fd >= 0)
                close_nointr_nofail(c->client_fd);

        close_pipe(c->server_to_client_buffer);
        close_pipe(c->client_to_server_buffer);

        free(c);
}
コード例 #25
0
ファイル: intset.c プロジェクト: dution89630/my-school-work
int set_move(intset_t *set, val_t val1, val_t val2, int transactional) {
  int result;

  if(transactional != 0) {
    TX_START(NL);
  }
  result = 0;
  if(!set_contains(set, val2, transactional)) {
    if(set_remove(set, val1, transactional)) {
      set_add(set, val2, transactional);
      result = 1;
    }
  }
  if(transactional != 0) {
    TX_END;
  }

  return result;
}
コード例 #26
0
ファイル: socket-proxyd.c プロジェクト: floppym/systemd
static void connection_free(Connection *c) {
        assert(c);

        if (c->context)
                set_remove(c->context->connections, c);

        sd_event_source_unref(c->server_event_source);
        sd_event_source_unref(c->client_event_source);

        safe_close(c->server_fd);
        safe_close(c->client_fd);

        safe_close_pair(c->server_to_client_buffer);
        safe_close_pair(c->client_to_server_buffer);

        sd_resolve_query_unref(c->resolve_query);

        free(c);
}
コード例 #27
0
ファイル: networkd-route.c プロジェクト: Werkov/systemd
int route_add(
              Link *link,
              int family,
              const union in_addr_union *dst,
              unsigned char dst_prefixlen,
              unsigned char tos,
              uint32_t priority,
              uint32_t table,
              Route **ret) {

        Route *route;
        int r;

        r = route_get(link, family, dst, dst_prefixlen, tos, priority, table, &route);
        if (r == -ENOENT) {
                /* Route does not exist, create a new one */
                r = route_add_internal(link, &link->routes, family, dst, dst_prefixlen, tos, priority, table, &route);
                if (r < 0)
                        return r;
        } else if (r == 0) {
                /* Take over a foreign route */
                r = set_ensure_allocated(&link->routes, &route_hash_ops);
                if (r < 0)
                        return r;

                r = set_put(link->routes, route);
                if (r < 0)
                        return r;

                set_remove(link->routes_foreign, route);
        } else if (r == 1) {
                /* Route exists, do nothing */
                ;
        } else
                return r;

        if (ret)
                *ret = route;

        return 0;
}
コード例 #28
0
ファイル: test-set.c プロジェクト: dlove24/dl-calg
void test_set_iterating_remove (void) {
  Set* set;
  SetIterator iterator;
  int count;
  unsigned int removed;
  char* value;

  set = generate_set();

  count = 0;
  removed = 0;

  /* Iterate over all values in the set */

  set_iterate (set, &iterator);

  while (set_iter_has_more (&iterator)) {

    value = set_iter_next (&iterator);

    if ( (atoi (value) % 100) == 0) {

      /* Remove this value */

      set_remove (set, value);

      ++removed;
      }

    ++count;
    }

  /* Check final counts */

  assert (count == 10000);
  assert (removed == 100);
  assert (set_num_entries (set) == 10000 - removed);

  set_free (set);
  }
コード例 #29
0
DnsTransaction* dns_transaction_free(DnsTransaction *t) {
        DnsQuery *q;
        DnsZoneItem *i;

        if (!t)
                return NULL;

        sd_event_source_unref(t->timeout_event_source);

        dns_packet_unref(t->sent);
        dns_packet_unref(t->received);
        dns_answer_unref(t->cached);

        sd_event_source_unref(t->dns_udp_event_source);
        safe_close(t->dns_udp_fd);

        dns_server_unref(t->server);
        dns_stream_free(t->stream);

        if (t->scope) {
                hashmap_remove(t->scope->transactions, t->key);

                if (t->id != 0)
                        hashmap_remove(t->scope->manager->dns_transactions, UINT_TO_PTR(t->id));
        }

        dns_resource_key_unref(t->key);

        while ((q = set_steal_first(t->queries)))
                set_remove(q->transactions, t);
        set_free(t->queries);

        while ((i = set_steal_first(t->zone_items)))
                i->probe_transaction = NULL;
        set_free(t->zone_items);

        free(t);
        return NULL;
}
コード例 #30
0
ファイル: graph.c プロジェクト: AnnatarHe/Algorithms-with-c
int graph_rem_edge(Graph *graph, void *data1, void **data2)
{
    ListElmt *element;

    // 定位第一个顶点的临近列表
    for (element = list_head(&graph->adjlists); element != NULL; element = list_next(element)) {
        if (graph->match(data1, ((AdjList *)list_data(element))->vertex)) {
            break;
        }
    }

    if (element == NULL) {
        return -1;
    }

    // 从第一个顶点的临近列表中移除第二个顶点
    if (set_remove(&((AdjList *)list_data(element))->adjacent, data2) != 0) {
        return -1;
    }

    // 为移除的边调整边的总数
    graph->ecount--;
    return 0;
}