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);
}
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);
}
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);
}
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;
}
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);
}
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);
}
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);
}
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;
}
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);
}
/* 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;
}
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;
}
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"}));
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"}));
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"}));
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"}));
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;
}
/**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);
}
}
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);
}
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;
}
}
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);
}
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;
}
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;
}
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);
}
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);
}
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;
}
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);
}
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;
}
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);
}
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;
}
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;
}