C++ remove_entry函数代码示例

int CassandraFS::unlink(const char* path) {
    struct stat stat;
    struct cfs_attrs cfs_attrs;
    int attr_err = getattr(path, &stat, &cfs_attrs);

    if (attr_err) {
        return attr_err;
    }
    
    CassandraFutureSpool *spool = new CassandraFutureSpool(4);

    spool->append(remove_entry(path));
    spool->append(remove_sub_entry(path));
    spool->append(remove_sub_entries(path));
    
    if (!S_ISDIR(stat.st_mode)) {
        remove_physical_file(&stat, &cfs_attrs, spool);
    }

    spool->wait_all();
    int errors = spool->get_errors();
    delete spool;
    
    if (errors > 0) {
        return -EIO;
    }
    
    return 0;
}

static void
remove_entry(IsStore *self,
	     IsStoreEntry *entry)
{
	IsStorePrivate *priv;
	GtkTreeIter iter;
	GtkTreePath *path;
	GSequenceIter *parent_iter;

	priv = self->priv;

	parent_iter = entry->parent;
	iter.stamp = priv->stamp;
	iter.user_data = entry->iter;
	path = gtk_tree_model_get_path(GTK_TREE_MODEL(self), &iter);
	g_sequence_remove(entry->iter);
	gtk_tree_model_row_deleted(GTK_TREE_MODEL(self), path);
	gtk_tree_path_free(path);

	/* remove parent if it has no children now */
	if (parent_iter) {
		IsStoreEntry *parent = g_sequence_get(parent_iter);
		if (g_sequence_get_length(parent->entries) == 0) {
			remove_entry(self, parent);
		}
	}
}

void econ_change_items(dbref d, int id, int brand, int num)
{
	char *t, *u;
	int base = 0, i1, i2, i3;

	if(!Good_obj(d))
		return;
	if(brand)
		if(get_parts_short_name(id, brand) == get_parts_short_name(id, 0))
			brand = 0;
	t = silly_atr_get(d, A_ECONPARTS);
	if((u = find_entry(t, id, brand))) {
		if(sscanf(u, "[%d,%d,%d]", &i1, &i2, &i3) == 3)
			base += i3;
		remove_entry(t, u);
	}
	base += num;
	if(base <= 0) {
		if(u)
			silly_atr_set(d, A_ECONPARTS, t);
		return;
	}
	if(!(IsActuator(id)))
		add_entry(t, tprintf("%d,%d,%d", id, brand, base));
	silly_atr_set(d, A_ECONPARTS, t);
	if(IsActuator(id))
		econ_change_items(d, Cargo(S_ACTUATOR), brand, base);
	/* Successfully changed */
}

int main(void) {
    struct entry e1, e2, e3, e4;
    struct entry first_entry;
    struct entry *list = &first_entry;

    first_entry.next = &e1;
    e1.value = 1;
    e1.next = &e2;
    e2.value = 2;
    e2.next = &e3;
    e3.value = 3;
    e3.next = &e4;
    e4.value = 4;
    e4.next = (struct entry *)0;

    remove_entry(&e3);

    list = list->next;
    while (list != (struct entry *)0) {
        printf("%i\n", list->value);
        list = list->next;
    }

    return 0;
}

void core_options::add_entries(const options_entry *entrylist, bool override_existing)
{
	// loop over entries until we hit a NULL name
	for ( ; entrylist->name != NULL || (entrylist->flags & OPTION_HEADER) != 0; entrylist++)
	{
		// allocate a new entry
		entry *newentry = new entry(*entrylist);
		if (newentry->name() != NULL)
		{
			// see if we match an existing entry
			entry *existing = m_entrymap.find(newentry->name());
			if (existing != NULL)
			{
				// if we're overriding existing entries, then remove the old one
				if (override_existing)
				{
					core_options::entry *e = m_entrylist;
					remove_entry(*existing);
					delete e;
				}

				// otherwise, just override the default and current values and throw out the new entry
				else
				{
					existing->set_default_value(newentry->value());
					delete newentry;
					continue;
				}
			}
		}

		// add us to the list and maps
		append_entry(*newentry);
	}
}

int main(int argc, char **argv) 
{
	CLIENT client_struct, *c;
        FLICK_SERVER_LOCATION s;
	int sel, done;
	
	c = &client_struct;
	
	if (argc != 2) {
		fprintf(stderr, "Usage: %s <host>\n", argv[0]);
		exit(1);
	}
	
	s.server_name = argv[1];
	s.prog_num = netphone;
	s.vers_num = firstphone;
	create_client(c, s);
	
	done = 0;
	while (!done) {
		read_integer(("\n(1) Add an entry (2) Remove an entry "
			      "(3) Find a phone number (4) Exit: "),
			     &sel);
		switch(sel) {
		case 1:  add_entry(c); break;
		case 2:  remove_entry(c); break;
		case 3:  find_entry(c); break;
		case 4:  done = 1; break;
		default: printf("Please enter 1, 2, 3, or 4.\n");
		}
	}
	return 0;
}

int ghostfs_rename(struct ghostfs *gfs, const char *path, const char *newpath)
{
	struct dir_iter it;
	struct dir_entry *entry;
	int ret;

	ret = dir_iter_lookup(gfs, &it, path, false);
	if (ret < 0)
		return ret;

	if (it.entry == &gfs->root_entry)
		return -EINVAL;

	remove_entry(gfs, newpath, false);

	ret = create_entry(gfs, newpath, false, &entry);
	if (ret < 0)
		return ret;

	// remove old entry
	it.entry->filename[0] = '\0';
	cluster_set_dirty(it.cluster, true);

	// fix new entry
	entry->size = it.entry->size;
	entry->cluster = it.entry->cluster;

	return 0;
}

static void elapse_func(AvahiTimeEvent *t, void *userdata) {
    AvahiCacheEntry *e = userdata;
/*     char *txt; */
    unsigned percent = 0;

    assert(t);
    assert(e);

/*     txt = avahi_record_to_string(e->record); */

    switch (e->state) {

        case AVAHI_CACHE_EXPIRY_FINAL:
        case AVAHI_CACHE_POOF_FINAL:
        case AVAHI_CACHE_GOODBYE_FINAL:
        case AVAHI_CACHE_REPLACE_FINAL:

            remove_entry(e->cache, e);

            e = NULL;
/*         avahi_log_debug("Removing entry from cache due to expiration (%s)", txt); */
            break;

        case AVAHI_CACHE_VALID:
        case AVAHI_CACHE_POOF:
            e->state = AVAHI_CACHE_EXPIRY1;
            percent = 85;
            break;

        case AVAHI_CACHE_EXPIRY1:
            e->state = AVAHI_CACHE_EXPIRY2;
            percent = 90;
            break;
        case AVAHI_CACHE_EXPIRY2:
            e->state = AVAHI_CACHE_EXPIRY3;
            percent = 95;
            break;

        case AVAHI_CACHE_EXPIRY3:
            e->state = AVAHI_CACHE_EXPIRY_FINAL;
            percent = 100;
            break;
    }

    if (e) {

        assert(percent > 0);

        /* Request a cache update if we are subscribed to this entry */
        if (avahi_querier_shall_refresh_cache(e->cache->interface, e->record->key))
            avahi_interface_post_query(e->cache->interface, e->record->key, 0, NULL);

        /* Check again later */
        next_expiry(e->cache, e, percent);

    }

/*     avahi_free(txt); */
}

void core_options::reset()
{
	// remove all entries from the list
	while (m_entrylist != NULL)
		remove_entry(*m_entrylist);

	// reset the map
	m_entrymap.reset();
}

/**
 * Tries to delete a person.
 */
void del(void)
{
    int i, num_del;
    if (num_list > 1)
    {
        // ask how many entry that user want to delete
        printf("How many entry do you want to delete? Choose 1~%i: ", num_list);
        scanf("%i", &num_del);
        for (i = 0; i < num_del - 1; i++)
        {
            remove_entry(); // delete (wanted number - 1) entries
        }
    }
    remove_entry(); // delete once more

    // print_list list
    print_list();
}

EXP_FUNC void STDCALL ax_free(void *y, const char* f, const int l)
{
    if(enable)  
        printf("free\t");
        
    remove_entry(y, f, l);
    print_buf_stats();
    free(y);
}

/*Test4 tests inserting a large number of keys, chekcing key_count, deleting a few, rechecking the
key_count, then clearing the entire table. We will then reinsert some keys.*/
static int test4(){
   int x = 1, y =2, z = 3, w =4, k = 5, a =6, b =7
   , c =8, d = 9, e = 10, f = 11, g = 12;
   Table *t;

   /*Creates table and adds 13 keys to it.*/
   create_table(&t, z, NULL);
   put(t, "Krabs", &a);
   put(t, "Larry", &b);
   put(t, "Herminator", &c);
   put(t, "Brian", &d);
   put(t, "Steve", &e);
   put(t, "Nelson", &f);
   put(t, "Corwin", &g);
   put(t, "Spongebob", &x);
   put(t, "Patrick", &y);
   put(t, "Squidward", &z);
   put(t, "Sandy", &w);
   put(t, "Art thou feeling it now,", NULL);
   put(t, "Mr. Krabs?", &k);
   printf("%d\n", get_key_count(t));
   display_table(t);
   /*Removes two keys from the table, then rechekcs key_count and
   displays the state of the table.*/
   remove_entry(t,"Mr. Krabs?");
   remove_entry(t,"Art thou feeling it now,");
   printf("%d\n", get_key_count(t));
   display_table(t);

   /*Clears the table, then rechecks the key_count.*/
   clear_table(t);
   printf("%d\n", get_key_count(t));
   /*Reinserts 7 keys, then checks the state of the table again.*/
   put(t, "A1", &a);
   put(t, "A2", &b);
   put(t, "A3", &c);
   put(t, "A4", &d);
   put(t, "A5", &e);
   put(t, "A6", &f);
   put(t, "A7", &g);
   display_table(t);
   destroy_table(t);
   return SUCCESS;
}

static bool create_two_story_trie(void)
{
	bool success = true;

	success &= add_entry("1.0.0.0", 32, "1::00", 120);
	success &= add_entry("2.0.0.0", 32, "1::10", 124);
	success &= add_entry("3.0.0.0", 32, "1::20", 124);

	success &= remove_entry(NULL, 0, "1::", 128, -ESRCH);
	success &= remove_entry(NULL, 0, "1::", 121, -ESRCH);
	success &= remove_entry(NULL, 0, "1::", 119, -ESRCH);
	success &= remove_entry(NULL, 0, "0::", 0, -ESRCH);

	success &= test("1.0.0.0", "1::00");
	success &= test("2.0.0.0", "1::10");
	success &= test("3.0.0.0", "1::20");

	return success;
}

core_options::~core_options()
{
	// delete all entries from the list
	while (m_entrylist != NULL)
	{
		core_options::entry *e = m_entrylist;
		remove_entry(*m_entrylist);
		delete e;
	}
}

    ReturnCode RamFileSystem::remove_entry(uint32_t entry_id)
    {
        if (entry_id == NULL_ID)
        {
            return NULL_PARAMETER;
        }

        // Cannot remove root
        if (entry_id == 1)
        {
            return WRONG_ENTRY_TYPE;
        }

        auto find = _entry_index.find(entry_id);
        if (find == _entry_index.end())
        {
            return ENTRY_NOT_FOUND;
        }

        auto type = find->second->metadata().type();

        if (type == FOLDER_ENTRY)
        {
            auto folder = dynamic_cast<Folder *>(find->second.get());
            if (folder != nullptr)
            {
                if (folder->size() > 0)
                {
                    return FOLDER_NOT_EMPTY;
                }
            }
        }

        auto parent_find = _entry_index.find(find->second->parent_folder_id());
        if (parent_find == _entry_index.end())
        {
            // Parent not found?
            return ENTRY_NOT_FOUND;
        }

        auto parent_folder = dynamic_cast<Folder *>(parent_find->second.get());
        if (parent_folder == nullptr)
        {
            // Parent wrong entry type?
            return WRONG_ENTRY_TYPE;
        }

        auto result = parent_folder->remove_entry(entry_id);
        if (result == SUCCESS)
        {
            _entry_index.erase(find);
        }

        return result;
    }