C++ delete_data函数代码示例

CUICellItem::~CUICellItem()
{
	if(m_b_destroy_childs)
		delete_data	(m_childs);

	delete_data		(m_custom_draw);
}

void CUIGameCustom::OnFrame() 
{
	CDialogHolder::OnFrame();
	st_vec_it it = m_custom_statics.begin();
	st_vec_it it_e = m_custom_statics.end();
	for(;it!=it_e;++it)
		(*it)->Update();

	std::sort(	it, it_e, predicate_sort_stat );

	
	while(!m_custom_statics.empty() && !m_custom_statics.back()->IsActual())
	{
		delete_data					(m_custom_statics.back());
		m_custom_statics.pop_back	();
	}
	
	if(g_b_ClearGameCaptions)
	{
		delete_data				(m_custom_statics);
		g_b_ClearGameCaptions	= false;
	}
	m_window->Update();

	//update windows
	if( GameIndicatorsShown() && psHUD_Flags.is(HUD_DRAW|HUD_DRAW_RT) )
		UIMainIngameWnd->Update	();

	m_pMessagesWnd->Update();
}

CGameSpawnConstructor::~CGameSpawnConstructor	()
{
	delete_data						(m_level_spawns);
	delete_data						(m_spawn_graph);
	xr_delete						(m_game_graph);
	xr_delete						(m_game_info);
	xr_delete						(m_patrol_path_storage);
}

CExtraContentFilter::~CExtraContentFilter()
{
	for (u32 i=0; i<aDataPacks.size(); i++)
	{
		delete_data(aDataPacks[i]);
	}
	delete_data(aDataPacks);
}

CUIGameSP::~CUIGameSP() 
{
	delete_data(InventoryMenu);
	delete_data(PdaMenu);	
	delete_data(TalkMenu);
	delete_data(UICarBodyMenu);
	delete_data(UIChangeLevelWnd);
}

CUIGameCTA::~CUIGameCTA()
{
    delete_data	(m_pUITeamSelectWnd);
    delete_data	(m_pBuySpawnMsgBox);
    xr_delete	(m_voteStatusWnd);
    xr_delete	(m_pCurBuyMenu);
    xr_delete	(m_pCurSkinMenu);
}

void CUISequencer::Destroy()
{
	Device.seqFrame.Remove		(this);
	Device.seqRender.Remove		(this);
	delete_data					(m_items);
	delete_data					(m_UIWindow);
	IR_Release					();
	m_bActive					= false;
	m_pStoredInputReceiver		= NULL;
}

CUIMMShniaga::~CUIMMShniaga()
{
	xr_delete(m_magnifier);
	xr_delete(m_shniaga);
	xr_delete(m_view);
	xr_delete(m_sound);

	delete_data(m_buttons);
	delete_data(m_buttons_new);
}

CGameSpy_Full::~CGameSpy_Full()
{
	delete_data(m_pGSA);
	delete_data(m_pGS_Patching);
	delete_data(m_pGS_HTTP);
	delete_data(m_pGS_SB);

	if (m_hGameSpyDLL)
	{
		FreeLibrary(m_hGameSpyDLL);
		m_hGameSpyDLL = NULL;
	}
}

		std::string SqliteDao::save()
		{
			int ret = 0;

			start_transaction();

            int table_num = table_manager_->get_schema_manager()->get_table_num();

            for (int i = 0; i < table_num; i++)
            {
			    db_mm::TableIndex* table_index = table_manager_->get_table_index(i);
			    db_mm::TableIndex::RowIndexIter row_iter = table_index->iter();

                if (!table_index->has_data())
                {
                    continue;
                }

			    db_mm::RowIndex* row_index = NULL;

			    while (0 == row_iter.get_next(row_index) && 0 == ret)
			    {
			    	if (db_mm::DELETE_ROW == row_index->get_row_stat())
			    	{
			    		ret = delete_data(row_index);
			    	}

			    	else if (db_mm::UPDATE_ROW == row_index->get_row_stat())
			    	{
			    		if (0 == ret && 0 == (ret = delete_data(row_index)))
			    		{
			    			ret = insert_data(row_index);
			    		}
			    	}
			    }
            }

			if (0 == ret)
			{
				commit();
			}

			else
			{
				error_msg_ = sqlite3_errmsg(sqlite_);
				roll_back();
			}

			return error_msg_;
		}

CUIPdaWnd::~CUIPdaWnd()
{
	delete_data		(UIMapWnd);
	delete_data		(UIPdaContactsWnd);
	delete_data		(UIEncyclopediaWnd);
	delete_data		(UIDiaryWnd);
	delete_data		(UIActorInfo);
	delete_data		(UIStalkersRanking);
	delete_data		(UIEventsWnd);
	delete_data		(m_updatedSectionImage);
	delete_data		(m_oldSectionImage);
}

void nghash_empty(NGHASHPTR hashtable, void (*delete_data) (void *),
                  void (*delete_key) (void *))
{
    NGTABLEPTR *table, hptr , zapptr ;

    nghash_reset_stat(hashtable);

    table = hashtable->hash_table ;
    if( table ) {
        for( hptr = hashtable->thread ; hptr ; ) {
            zapptr = hptr ;
            hptr = hptr->thread_next ;

            /* execute user define delete function if requested */
            if( delete_data ) {
                delete_data (zapptr->data);
            }
            if( hashtable->hash_func == NGHASH_DEF_HASH(NGHASH_FUNC_STR) ) {
                /* we allocated this ourselves we can delete it */
                NGFREE( zapptr->key ) ;
            } else if( delete_key ) {
                delete_key (zapptr->key);
            }
            NGFREE( zapptr ) ;
        }
        memset(table, 0, (size_t) hashtable->size*sizeof(NGTABLEPTR)) ;
    }
    /* free decks associated with tree if they exist */
    hashtable->thread = NULL ; /* initialize list */
    hashtable->last_entry = NULL ; /* initialize list */
    hashtable->num_entries = 0 ;
} /* end nghash_empty() */

void delete_tokenizer(tokenizer_t *tokenizer)
{
    delete_data(tokenizer);
    free(tokenizer->comment_lines);
    free(tokenizer->buf);
    free(tokenizer);
}

 /// free memory and set number of elements to zero
 void clear(void)
 {   length_ = 0;
     // check if there is old memory to be freed
     if( capacity_ > 0 )
         delete_data(data_);
     capacity_ = 0;
 }

void CSpaceRestrictionManager::clear						()
{
	m_clients->clear				();
	delete_data						(m_space_restrictions);

	CSpaceRestrictionHolder::clear	();
}