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

CInventoryItem::~CInventoryItem() 
{
	delete_data			(m_net_updateData);	
	static int destr_no = 0;
	u16 id = 0;
	if (m_object)
		id = m_object->ID();

	destr_no++;
	// Msg("* [%3d] destroying CInventoryItem 0x%08p #%5d '%s', m_object = %p ", destr_no, this, id, m_name.c_str(), m_object);			

#ifdef INV_NEW_SLOTS_SYSTEM
	R_ASSERT2((int)m_slots.size() >= 0, "m_slots.size() returned negative value inside destructor!"); // alpet: для детекта повреждения объекта
#endif


	bool B_GOOD			= (	!m_pCurrentInventory || 
							(std::find(	m_pCurrentInventory->m_all.begin(),m_pCurrentInventory->m_all.end(), this)==m_pCurrentInventory->m_all.end()) );
	if(!B_GOOD)
	{
		CObject* p	= object().H_Parent();
		Msg("inventory ptr is [%s]",m_pCurrentInventory?"not-null":"null");
		if(p)
			Msg("parent name is [%s]",p->Name_script());

			Msg("! ERROR item_id[%d] H_Parent=[%s][%d] [%d]",
				object().ID(),
				p ? p->Name_script() : "none",
				p ? p->ID() : -1,
				Device.dwFrame
				);
	}
}

double delete_test(OSyncEngine *engine, OSyncMember *member, int num, const char *objtype)
{
	printf("Test \"Delete %i\" starting", num);
	fflush(stdout);

	empty_all(engine);

	printf(".");
	fflush(stdout);
	int i = 0;
	for (i = 0; i < num; i++)
		add_data(member, objtype);
	printf(".");
	fflush(stdout);

	check_sync(engine, "None", num);

	printf(".");
	fflush(stdout);
	delete_data(member, objtype);
	printf(".");
	fflush(stdout);

	return check_sync(engine, "Delete", num);
}

void CUIGameTDM::UnLoad()
{
	inherited::UnLoad	();
	xr_delete			(m_team1_icon);
	xr_delete			(m_team2_icon);
	delete_data			(m_pUITeamSelectWnd);
}

void put_template(char *template_name, int x, int y)
{
	printf("Placing \"%s\" template at (%d, %d)\n", template_name, x, y);
	int i = 0;
	int j = 0;
	Template *t = get_template(template_name);

	if (t->width > width || t->height > height)
	{
		printf("The game field is too small to put the \"%s\" template.\n", template_name);
		delete_data();
		exit(3);
	}

	for (i = 0; i < t->height; i++)
	{
		for (j = 0; j < t->width; j++)
		{
			if (t->picture[i][j])
			{
				field[(y + i) % height][(x + j) % width] = 1;
			}
		}
	}

	delete_template(t);
}

void test_delete(splay_tree* t, int data){
  print_tree(*t);
  printf("\n");
  *t =delete_data(*t, data);
  print_tree(*t);
  printf("\n");
}