chooser::pitem chooser::delete_element(pitem p) { pitem res = nullptr; if (!p->L && !p->R) { if (p->parent) { res = p->parent; if (is_left_child(p)) { res->L = nullptr; } else { res->R = nullptr; } } delete p; } else if (!p->L || !p->R) { if (p->parent) { res = p->parent; if (is_left_child(p)) { res->L = p->L ? p->L : p->R; } else { res->R = p->L ? p->L : p->R; } p->L = p->R = nullptr; delete p; } else { if (p->L) { right_rotale(p); } else { left_rotale(p); } return delete_element(p); } } else { pitem q = leftmost_child(p->R); if (q != p->R) { std::swap(p->L, q->L); std::swap(p->R, q->R); recalc(p); recalc(q); const pitem p_par = p->parent; make_parent(q->parent, p); make_parent(p_par, q); } else { left_rotale(p); } assert(!p->L || !p->R); delete_element(p); res = q->parent ? q->parent : q; } recalc(res); return splay(res); }
int main() { int option; printf("\n"); printf(">>> c program to implement queue operations <<<"); do { printf("\n\n 1.Insert an element"); printf("\n 2.Delete an element"); printf("\n 3.Display queue"); printf("\n 4.Exit"); printf("\n Enter your choice: "); scanf("%d",&option); switch(option) { case 1: insert_element(); break; case 2: delete_element(); break; case 3: display_queue(); break; case 4: return 0; } }while(option!=4); }
void delete_match_entry( struct ofp_match *ofp_match ) { match_entry *delete_entry; list_element *list; pthread_mutex_lock( match_table_head.mutex ); assert( ofp_match != NULL ); if ( !ofp_match->wildcards ) { delete_entry = delete_hash_entry( match_table_head.exact_table, ofp_match ); if ( delete_entry == NULL ) { pthread_mutex_unlock( match_table_head.mutex ); return; } } else { for ( list = match_table_head.wildcard_table; list != NULL; list = list->next ) { delete_entry = list->data; if ( ( ( ( delete_entry->ofp_match.wildcards ^ ofp_match->wildcards ) & OFPFW_ALL ) == 0 ) && compare_match( &delete_entry->ofp_match, ofp_match ) ) { break; } } if ( list == NULL ) { pthread_mutex_unlock( match_table_head.mutex ); return; } delete_element( &match_table_head.wildcard_table, delete_entry ); } free_match_entry( delete_entry ); pthread_mutex_unlock( match_table_head.mutex ); }
int main() { Sant* santi=(Sant*)malloc(sizeof(Sant)); initializeSent(santi); //santi->head=NULL; // santi->tail=NULL; char s[30]; int x; out=fopen("out.txt","w"); in=fopen("in.txt","r"); int c; c=fscanf(in,"%s %d",s,&x); while(c>0) { //printf("%s %d\n",s,x); if(!strcmp(s,"AL"))addLast(santi,x); if(!strcmp(s,"AF"))addFirst(santi,x); if(!strcmp(s,"DE"))delete_element(santi,x); if(!strcmp(s,"PRINT_F"))print_first(santi,x); if(!strcmp(s,"PRINT_L"))print_last(santi,x); if(!strcmp(s,"PRINT_ALL"))printlist(santi); if(!strcmp(s,"DOOM_THE_LIST"))doom_the_list(santi); if(!strcmp(s,"DF"))delete_first(santi); if(!strcmp(s,"DL"))delete_last(santi); strcpy(s,""); c=fscanf(in,"%s %d",s,&x); } return 0; }
void delete_texture(void **texs, void *tex) { Texture *t = (Texture *)tex; free(t->name); glDeleteTextures(1, &t->gltex); delete_element((void **)texs, tex); }
static void handle_packet_in( uint64_t datapath_id, uint32_t transaction_id, uint32_t buffer_id, uint16_t total_len, uint16_t in_port, uint8_t reason, const buffer *data, void *user_data ) { services *services = user_data; list_element **list_head = &services->arp_or_unicast; packet_info *packet_info = data->user_data; if ( !packet_type_arp( data ) && ( packet_info->eth_macda[ 0 ] & 0x1 ) == 0x1 ) { list_head = &services->broadcast; } if ( *list_head == NULL ) { return; } buffer *buf = create_packet_in( transaction_id, buffer_id, total_len, in_port, reason, data ); openflow_service_header_t *message; message = append_front_buffer( buf, sizeof( openflow_service_header_t ) ); message->datapath_id = htonll( datapath_id ); message->service_name_length = htons( 0 ); char *service_name = ( *list_head )->data; if ( send_message( service_name, MESSENGER_OPENFLOW_MESSAGE, buf->data, buf->length ) ) { debug( "Sending a message to %s.", service_name ); } free_buffer( buf ); if ( ( *list_head )->next != NULL ) { //round robin delete_element( list_head, service_name ); append_to_tail( list_head, service_name ); } }
static int delete_packetin_match_entry( struct ofp_match match, uint16_t priority, const char *service_name ) { list_element *head = delete_match_strict_entry( match, priority ); if ( head == NULL ) { return 0; } int n_deleted = 0; int n_remaining_services = 0; list_element *services = head; while ( services != NULL ) { char *service = services->data; services = services->next; if ( strcmp( service, service_name ) == 0 ) { delete_element( &head, service ); xfree( service ); n_deleted++; } else { n_remaining_services++; } } if ( n_remaining_services == 0 ) { if ( head != NULL ) { delete_list( head ); } } else { insert_match_entry( match, priority, head ); } return n_deleted; }
int loop_exit(loop_handle *hd) { int i; hd->running = FALSE; if(hd->svdst != NULL) { if (hd->fifodst != NULL) { sv_fifo_free(hd->svdst, hd->fifodst); hd->fifodst = NULL; } if(hd->svdst != hd->svsrc) { sv_close(hd->svdst); hd->svdst = NULL; } } if (hd->svsrc != NULL) { if (hd->fifosrc != NULL) { sv_fifo_free(hd->svsrc, hd->fifosrc); hd->fifosrc = NULL; } sv_close(hd->svsrc); hd->svsrc = NULL; } if(hd->nobuffer_org) { free(hd->nobuffer_org); } if(hd->blackbuffer_org) { free(hd->blackbuffer_org); } for(i = 0; i < MAX_ID; i++) { if(hd->ancbuffer_org[i]) { free(hd->ancbuffer_org[i]); } if(hd->livebuffer_org[i]) { free(hd->livebuffer_org[i]); } if(hd->banc) { //If there are valid packets delete them if( hd->anclist[i].next ) { //Delete all elements in list delete_element( i, hd->anclist[i].next ); } } } dvs_mutex_free(&hd->common.lock); dvs_cond_free(&hd->common.ready); printf("exiting dma loop through\n"); return 0; }
void delete_element( int id, anc_element_t * anc_element ) { if( anc_element ) { if( anc_element->next ) { delete_element( id, anc_element->next ); } free( anc_element ); } }
void _delete_projectile(void **projs, void *proj) { Projectile *p = proj; p->rule(p, EVENT_DEATH); if(p->clr) free(p->clr); del_ref(proj); delete_element(projs, proj); }
void _delete_laser(void **lasers, void *laser) { Laser *l = laser; if(l->lrule) l->lrule(l, EVENT_DEATH); if(l->color) free(l->color); del_ref(laser); delete_element(lasers, laser); }
/***************************************************************************** * GdipDeleteRegion [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipDeleteRegion(GpRegion *region) { TRACE("%p\n", region); if (!region) return InvalidParameter; delete_element(®ion->node); heap_free(region); return Ok; }
OFDPE delete_meter_entry( const uint32_t meter_id ) { assert( table != NULL ); if ( meter_id == 0 && meter_id <= OFPM_MAX && meter_id != OFPM_CONTROLLER && meter_id != OFPM_ALL ) { return ERROR_OFDPE_METER_MOD_FAILED_INVALID_METER; } OFDPE ret = OFDPE_SUCCESS; if ( !lock_pipeline() ) { return ERROR_LOCK; } if ( meter_id == OFPM_ALL ) { delete_flow_entries_by_meter_id( meter_id ); for ( list_element *e = table->entries; e != NULL; ) { list_element *next = e->next; meter_entry *entry = e->data; if ( entry->meter_id > 0 && entry->meter_id <= OFPM_MAX ) { // virtual meters won't be deleted by OFPM_ALL delete_element( &table->entries, entry ); free_meter_entry( entry ); } e = next; } } else { meter_entry *old_entry = lookup_meter_entry( meter_id ); if ( NULL == old_entry ) { ret = ERROR_OFDPE_METER_MOD_FAILED_UNKNOWN_METER; } else { if ( old_entry->ref_count > 0 ) { delete_flow_entries_by_meter_id( meter_id ); } delete_element( &table->entries, old_entry ); free_meter_entry( old_entry ); } } if ( !unlock_pipeline() ) { return ERROR_UNLOCK; } return ret; }
static void delete_outbound_switch( list_element **switches, switch_info *delete_switch ) { list_element *ports = delete_switch->ports; // delete ports for ( list_element *p = ports; p != NULL; p = p->next ) { xfree( p->data ); } delete_list( ports ); // delete switch delete_element( switches, delete_switch ); xfree( delete_switch ); }
GpStatus WINGDIPAPI GdipSetInfinite(GpRegion *region) { GpStatus stat; TRACE("%p\n", region); if (!region) return InvalidParameter; delete_element(®ion->node); stat = init_region(region, RegionDataInfiniteRect); return stat; }
int remove_duplicate(SLink **head) { //to keep track of next next link for duplicate cases SLink *nextNext, *result; //if empty link if (NULL == (*head)) { return EMPTYLIST; } //sort the given list insert_sort(head); /* take a local reference of head */ SLink *temp; temp = *head; //if single node if((*head) -> link == NULL) { return SUCCESS; } { /* if list has multiple nodes then, iterate till tail node */ while (temp -> link) { if (temp -> data != (temp -> link) -> data) { /* if no element is found at all then return */ if (((temp->link)-> link ) == NULL) { return SUCCESS; } temp = temp -> link; } else { nextNext = temp -> link; delete_element(head, temp -> data); temp = nextNext; } } return SUCCESS; } return FAILURE; }
static void delete_flow_entry_from_table( flow_table *table, flow_entry *entry, uint8_t reason, bool notify ) { assert( table != NULL ); assert( entry != NULL ); bool ret = delete_element( &table->entries, entry ); if ( ret ) { decrement_active_count( table->features.table_id ); if ( notify ) { flow_deleted( entry, reason ); } decrement_reference_counters_in_groups( entry->instructions ); free_flow_entry( entry ); } }
int delete_mineral(t_cell *cell, t_mineral mineral) { t_link *tmp; t_minerals *min; tmp = cell->minerals->first; while (tmp) { min = (t_minerals *)(tmp->data); if (min->value == mineral) return (delete_element(cell->minerals, tmp->data)); tmp = tmp->next; } return (-1); }
int main(int argc, char ** argv) { int i,len; dll_t *dll; int array[] = {23,4,34,2,134}; len = sizeof(array)/sizeof(int); dll = init_double_link(); for (i = 0; i < len; i++) { insert_key_double_link(dll,array[i]); } printf("traverse\n"); traverse(dll); printf("after DELETE 23traverse\n"); delete_element(dll,23); traverse(dll); printf("after DELETE 2 traverse\n"); delete_element(dll,2); traverse(dll); delete_element(dll,55); traverse(dll); return 0; }
static inline GpStatus clone_element(const region_element* element, region_element** element2) { GpStatus stat; /* root node is allocated with GpRegion */ if(!*element2){ *element2 = GdipAlloc(sizeof(region_element)); if (!*element2) return OutOfMemory; } (*element2)->type = element->type; switch (element->type) { case RegionDataRect: (*element2)->elementdata.rect = element->elementdata.rect; break; case RegionDataEmptyRect: case RegionDataInfiniteRect: break; case RegionDataPath: (*element2)->elementdata.pathdata.pathheader = element->elementdata.pathdata.pathheader; stat = GdipClonePath(element->elementdata.pathdata.path, &(*element2)->elementdata.pathdata.path); if (stat != Ok) goto clone_out; break; default: (*element2)->elementdata.combine.left = NULL; (*element2)->elementdata.combine.right = NULL; stat = clone_element(element->elementdata.combine.left, &(*element2)->elementdata.combine.left); if (stat != Ok) goto clone_out; stat = clone_element(element->elementdata.combine.right, &(*element2)->elementdata.combine.right); if (stat != Ok) goto clone_out; break; } return Ok; clone_out: delete_element(*element2); *element2 = NULL; return stat; }
struct table_element *set_intersect(struct table_element * e1, struct table_element *e2) { int status; struct table_element *result = kmalloc(sizeof(struct table_element), GFP_KERNEL); result->read_only = 1; if (!result) goto fail; status = 0; result->root = treap_intersect(e1->root, e2->root, &status); if (status == NO_MEMORY) goto fail; result->count = count(result->root); return result; fail: delete_element(result); return NULL; }
ERRORCODE RecordArray::remove(DB_RECORD_NUMBER record) { // Find the record. int i = find(record); // If we didn't find it, we can't delete it. if (i == -1) { return ERRORCODE_BadParameter; } else { // Delete it! return delete_element(i); } }
static void * delete_wildcards_match_strict_entry( list_element **wildcards_table, struct ofp_match *match, uint16_t priority ) { assert( match != NULL ); match_entry *entry = lookup_wildcards_match_strict_entry( *wildcards_table, match, priority ); if ( entry == NULL ) { char match_string[ MATCH_STRING_LENGTH ]; match_to_string( match, match_string, sizeof( match_string ) ); warn( "wildcards match entry not found ( match = [%s], priority = %u )", match_string, priority ); return NULL; } void *data = entry->data; delete_element( wildcards_table, entry ); free_match_entry( entry ); return data; }
void select_delete(unsigned int* number_of_nodes) { if(0 == *number_of_nodes){ puts("the tree is basically empty, first create a root node and some leafs to delete"); return; } unsigned int select=0; do{ printf("\n\navailable delete operations:\n"); printf("0\tcancel\n"); printf("1\tdelete a leaf\n"); printf("2\tdelete a tree part\n"); printf("3\tdelete a node\n"); readdigit(&select, "select an operation:"); if(1 == select){ if(0 == *number_of_nodes){ puts("the tree is empty, first create one before you like to delete the entire thing!"); }else{ if(0 > delete_tree(number_of_nodes)){ puts("failed."); }else{ printf("%d elements\ndone.\n", *number_of_nodes); } } break; }else if(2 == select){ if(0 > delete_leaf(number_of_nodes)){ puts("failed."); }else{ printf("deleted.\n%d elements\ndone.\n", *number_of_nodes); } break; }else if(3 == select){ if(0 > delete_element(number_of_nodes)){ puts("failed."); }else{ printf("deleted.\n%d elements\ndone.\n", *number_of_nodes); } break; } }while(0 != select); }
void test3(void) { ElementNode_handle pE2=0; int i; printf("\n====== DELETE FRONT ====================\n"); for(i=0;i<5;++i) insert_element(&pE2,i,i+1); /*no 0s in the list*/ printf("vector 2 formatted:\n"); printf_elements(pE2,"%4d",5); printf("\n"); printf("vector 2 raw:\n"); print_elements(pE2); printf("\n"); delete_element(&pE2,0); printf("vector 2 formatted:\n"); printf_elements(pE2,"%4d",5); printf("\n"); printf("vector 2 raw:\n"); print_elements(pE2); printf("\n"); free_elements(pE2); }
/***************************************************************************** * GdipCombineRegionRect [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion *region, GDIPCONST GpRectF *rect, CombineMode mode) { GpRegion *rect_region; region_element *left, *right = NULL; GpStatus stat; TRACE("%p %s %d\n", region, debugstr_rectf(rect), mode); if (!(region && rect)) return InvalidParameter; stat = GdipCreateRegionRect(rect, &rect_region); if (stat != Ok) return stat; /* simply replace region data */ if(mode == CombineModeReplace){ delete_element(®ion->node); memcpy(region, rect_region, sizeof(GpRegion)); heap_free(rect_region); return Ok; } left = heap_alloc_zero(sizeof(region_element)); if (left) { memcpy(left, ®ion->node, sizeof(region_element)); stat = clone_element(&rect_region->node, &right); if (stat == Ok) { fuse_region(region, left, right, mode); GdipDeleteRegion(rect_region); return Ok; } } else stat = OutOfMemory; heap_free(left); GdipDeleteRegion(rect_region); return stat; }
/***************************************************************************** * GdipCombineRegionRect [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipCombineRegionRect(GpRegion *region, GDIPCONST GpRectF *rect, CombineMode mode) { GpRegion *rect_region; region_element *left, *right = NULL; GpStatus stat; TRACE("%p %p %d\n", region, rect, mode); if (!(region && rect)) return InvalidParameter; stat = GdipCreateRegionRect(rect, &rect_region); if (stat != Ok) return stat; /* simply replace region data */ if(mode == CombineModeReplace){ delete_element(®ion->node); memcpy(region, rect_region, sizeof(GpRegion)); GdipFree(rect_region); return Ok; } left = GdipAlloc(sizeof(region_element)); if (!left) goto out; memcpy(left, ®ion->node, sizeof(region_element)); stat = clone_element(&rect_region->node, &right); if (stat != Ok) goto out; fuse_region(region, left, right, mode); GdipDeleteRegion(rect_region); return Ok; out: GdipFree(left); GdipDeleteRegion(rect_region); return stat; }
/***************************************************************************** * GdipCombineRegionPath [GDIPLUS.@] */ GpStatus WINGDIPAPI GdipCombineRegionPath(GpRegion *region, GpPath *path, CombineMode mode) { GpRegion *path_region; region_element *left, *right = NULL; GpStatus stat; TRACE("%p %p %d\n", region, path, mode); if (!(region && path)) return InvalidParameter; stat = GdipCreateRegionPath(path, &path_region); if (stat != Ok) return stat; /* simply replace region data */ if(mode == CombineModeReplace){ delete_element(®ion->node); memcpy(region, path_region, sizeof(GpRegion)); heap_free(path_region); return Ok; } left = heap_alloc_zero(sizeof(region_element)); if (left) { *left = region->node; stat = clone_element(&path_region->node, &right); if (stat == Ok) { fuse_region(region, left, right, mode); GdipDeleteRegion(path_region); return Ok; } } else stat = OutOfMemory; heap_free(left); GdipDeleteRegion(path_region); return stat; }
/****************************************************** * clear_empty_macs * * input : * * -list : pointer to the address of the list * * to clear. * * output : * * -NONE * * desc : * * This function delete all element of the * * input list which has their rssi list empty. * * * *******************************************************/ void clear_empty_macs(Element ** list) { Element * pTmp = *list; Element * pTmp2 = NULL; //go through the list while (pTmp != NULL) { //if the current element has an empty rssi sample list if (pTmp->measurements.head == NULL && pTmp->measurements.tail == NULL) { //get next element pTmp2 = pTmp->next; //deleete element from the list delete_element(list, pTmp); //restore the element pTmp = pTmp2; } else //get next element pTmp= pTmp->next; } return ; }
int main() { int i, num; head = NULL; while(1) { printf("\nList Operations\n"); printf("===============\n"); printf("1.Insert\n"); printf("2.Display\n"); printf("3.Size\n"); printf("4.Delete\n"); printf("5.Exit\n"); printf("Enter your choice : "); if(scanf("%d",&i)<=0){ printf("Enter only an Integer\n"); continue; } else { switch(i) { case 1: printf("Enter the number to be inserted.\n"); scanf("%d", &num); insert_element(num); break; case 2: display_list(head); break; case 3: size(head); break; case 4: printf("Enter the element to be deleted.\n"); scanf("%d", &num); delete_element(num); break; case 5: return 0; default: printf("Invalid Operation.\n"); break; } } } return 0; }