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;
}
