//virtual void LLConsole::clear() { mTimer.reset(); LLMutexLock lock(&mQueueMutex); std::for_each(mParagraphs.begin(), mParagraphs.end(), DeletePointer()); mParagraphs.clear(); std::for_each(mNewParagraphs.begin(), mNewParagraphs.end(), DeletePointer()); mNewParagraphs.clear(); }
////----------------- /// FFMultiSet::clear //--------------------- // Cleans up. // void FFMultiSet::clear() { mConfig = NULL; for ( int i = 0 ; i < mSet.size() ; i++ ){ DeletePointer( mSet[ i ] ); } mSet.clear(); DeletePointer( mDevices ); }
// Destroys the object LLFloaterPay::~LLFloaterPay() { std::for_each(mCallbackData.begin(), mCallbackData.end(), DeletePointer()); // Clean up if we are still waiting for a name. gCacheName->cancelCallback(mTargetUUID,onCacheOwnerName,this); }
LLViewerRegion::~LLViewerRegion() { if(mHttpResponderPtr) { (static_cast<BaseCapabilitiesComplete*>(mHttpResponderPtr.get()))->setRegion(NULL) ; } gVLManager.cleanupData(this); // Can't do this on destruction, because the neighbor pointers might be invalid. // This should be reference counted... disconnectAllNeighbors(); mCloudLayer.destroy(); LLViewerPartSim::getInstance()->cleanupRegion(this); gObjectList.killObjects(this); delete mCompositionp; delete mParcelOverlay; delete mLandp; delete mEventPoll; LLHTTPSender::clearSender(mHost); saveObjectCache(); std::for_each(mObjectPartition.begin(), mObjectPartition.end(), DeletePointer()); }
void LLDrawable::destroy() { if (gDebugGL) { gPipeline.checkReferences(this); } if (isDead()) { sNumZombieDrawables--; } if (LLSpatialGroup::sNoDelete) { llerrs << "Illegal deletion of LLDrawable!" << llendl; } std::for_each(mFaces.begin(), mFaces.end(), DeletePointer()); mFaces.clear(); /*if (!(sNumZombieDrawables % 10)) { llinfos << "- Zombie drawables: " << sNumZombieDrawables << llendl; }*/ }
void LLXferManager::cleanup () { LLXfer *xferp; LLXfer *delp; for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer()); mOutgoingHosts.clear(); delp = mSendList; while (delp) { xferp = delp->mNext; delete delp; delp = xferp; } mSendList = NULL; delp = mReceiveList; while (delp) { xferp = delp->mNext; delete delp; delp = xferp; } mReceiveList = NULL; }
LLCacheName::Impl::~Impl() { for_each(mCache.begin(), mCache.end(), DeletePairedPointer()); mCache.clear(); for_each(mReplyQueue.begin(), mReplyQueue.end(), DeletePointer()); mReplyQueue.clear(); }
LLBufferArray::~LLBufferArray() { LLMemType m1(LLMemType::MTYPE_IO_BUFFER); std::for_each(mBuffers.begin(), mBuffers.end(), DeletePointer()); delete mMutexp; }
LLCurlRequest::~LLCurlRequest() { llassert_always(mThreadID == LLThread::currentID()); //stop all Multi handle background threads for (curlmulti_set_t::iterator iter = mMultiSet.begin(); iter != mMultiSet.end(); ++iter) { LLCurl::Multi* multi = *iter; if (multi->mThreaded) multi->mSignal->lock(); multi->mQuitting = true; if (multi->mThreaded) { while (!multi->isStopped()) { multi->mSignal->signal(); multi->mSignal->unlock(); apr_sleep(1000); multi->mSignal->lock(); } } if (multi->mThreaded) multi->mSignal->unlock(); } for_each(mMultiSet.begin(), mMultiSet.end(), DeletePointer()); }
LLCurl::Multi::~Multi() { llassert(isStopped()); if (LLCurl::sMultiThreaded) { LLCurl::Easy::sMultiMutex->lock(); } delete mSignal; mSignal = NULL; // Clean up active for(easy_active_list_t::iterator iter = mEasyActiveList.begin(); iter != mEasyActiveList.end(); ++iter) { Easy* easy = *iter; check_curl_multi_code(curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle())); delete easy; } mEasyActiveList.clear(); mEasyActiveMap.clear(); // Clean up freed for_each(mEasyFreeList.begin(), mEasyFreeList.end(), DeletePointer()); mEasyFreeList.clear(); check_curl_multi_code(curl_multi_cleanup(mCurlMultiHandle)); --gCurlMultiCount; if (LLCurl::sMultiThreaded) { LLCurl::Easy::sMultiMutex->unlock(); } }
void LLDrawable::deleteFaces(S32 offset, S32 count) { face_list_t::iterator face_begin = mFaces.begin() + offset; face_list_t::iterator face_end = face_begin + count; std::for_each(face_begin, face_end, DeletePointer()); mFaces.erase(face_begin, face_end); }
void LLCurl::cleanupClass() { #if SAFE_SSL CRYPTO_set_locking_callback(NULL); for_each(sSSLMutex.begin(), sSSLMutex.end(), DeletePointer()); #endif curl_global_cleanup(); }
// Destroys the object LLFloaterPay::~LLFloaterPay() { std::for_each(mCallbackData.begin(), mCallbackData.end(), DeletePointer()); // Name callbacks will be automatically disconnected since LLFloater is trackable // In case this floater is currently waiting for a reply. gMessageSystem->setHandlerFuncFast(_PREHASH_PayPriceReply, 0, 0); }
LLToastNotifyPanel::~LLToastNotifyPanel() { mButtonClickConnection.disconnect(); std::for_each(mBtnCallbackData.begin(), mBtnCallbackData.end(), DeletePointer()); mBtnCallbackData.clear(); if (mIsTip) { LLNotifications::getInstance()->cancel(mNotification); } }
// virtual LLNotifyBox::~LLNotifyBox() { delete mBehavior; mBehavior = NULL; std::for_each(mBtnCallbackData.begin(), mBtnCallbackData.end(), DeletePointer()); if (mUnique) { sOpenUniqueNotifyBoxes.erase(getName() + mMessage); } }
LLToastNotifyPanel::~LLToastNotifyPanel() { mButtonClickConnection.disconnect(); std::for_each(mBtnCallbackData.begin(), mBtnCallbackData.end(), DeletePointer()); if (mCloseNotificationOnDestroy && LLNotificationsUtil::find(mNotification->getID()) != NULL) { // let reusable notification be deleted mNotification->setReusable(false); LLNotifications::getInstance()->cancel(mNotification); } }
// Called from either the main thread or the worker thread void LLTextureCache::readHeaderCache(apr_pool_t* poolp) { LLMutexLock lock(&mHeaderMutex); mHeaderEntriesInfo.mVersion = 0.f; mHeaderEntriesInfo.mEntries = 0; if (ll_apr_file_exists(mHeaderEntriesFileName, poolp)) { ll_apr_file_read_ex(mHeaderEntriesFileName, poolp, (U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo)); } if (mHeaderEntriesInfo.mVersion != sHeaderCacheVersion) { if (!mReadOnly) { // Info with 0 entries mHeaderEntriesInfo.mVersion = sHeaderCacheVersion; ll_apr_file_write_ex(mHeaderEntriesFileName, poolp, (U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo)); } } else { S32 num_entries = mHeaderEntriesInfo.mEntries; if (num_entries) { Entry* entries = new Entry[num_entries]; ll_apr_file_read_ex(mHeaderEntriesFileName, poolp, (U8*)entries, sizeof(EntriesInfo), num_entries*sizeof(Entry)); typedef std::set<lru_data*, lru_data::Compare> lru_set_t; lru_set_t lru; for (S32 i=0; i<num_entries; i++) { if (entries[i].mSize >= 0) // -1 indicates erased entry, skip { const LLUUID& id = entries[i].mID; lru.insert(new lru_data(entries[i].mTime, i, id)); mHeaderIDMap[id] = i; } } mLRU.clear(); S32 lru_entries = sCacheMaxEntries / 10; for (lru_set_t::iterator iter = lru.begin(); iter != lru.end(); ++iter) { lru_data* data = *iter; mLRU[data->index] = data->uuid; if (--lru_entries <= 0) break; } for_each(lru.begin(), lru.end(), DeletePointer()); delete[] entries; } } }
LLLayoutStack::~LLLayoutStack() { // <FS:Zi> Save new sizes for this layout stack's panels if (mSaveSizes) { LLUI::sSettingGroups["account"]->setLLSD(mSizeControlName, mSavedSizes); } // </FS:Zi> e_panel_list_t panels = mPanels; // copy list of panel pointers mPanels.clear(); // clear so that removeChild() calls don't cause trouble std::for_each(panels.begin(), panels.end(), DeletePointer()); }
void LLScrollListItem::setNumColumns(S32 columns) { S32 prev_columns = mColumns.size(); if (columns < prev_columns) { std::for_each(mColumns.begin()+columns, mColumns.end(), DeletePointer()); } mColumns.resize(columns); for (S32 col = prev_columns; col < columns; ++col) { mColumns[col] = NULL; } }
void LLFloaterReporter::setDescription(const std::string& description, LLMeanCollisionData *mcd) { LLFloaterReporter *self = gReporterInstances[COMPLAINT_REPORT]; if (self) { self->childSetText("details_edit", description); for_each(self->mMCDList.begin(), self->mMCDList.end(), DeletePointer()); self->mMCDList.clear(); if (mcd) { self->mMCDList.push_back(new LLMeanCollisionData(mcd)); } } }
void LLDrawable::cleanupReferences() { LLFastTimer t(LLFastTimer::FTM_PIPELINE); std::for_each(mFaces.begin(), mFaces.end(), DeletePointer()); mFaces.clear(); gObjectList.removeDrawable(this); gPipeline.unlinkDrawable(this); // Cleanup references to other objects mVObjp = NULL; mParent = NULL; }
FFSet::~FFSet() { for ( TInclude::iterator itInclude = mInclude.begin() ; itInclude != mInclude.end() ; itInclude++ ){ for ( TProject::iterator itProject = (*itInclude).begin() ; itProject != (*itInclude).end() ; itProject++ ){ DeletePointer( (*itProject).second ); } } }
//----------------------------------------------------------------------------- // deleteAllMotions() //----------------------------------------------------------------------------- void LLMotionController::deleteAllMotions() { mLoadingMotions.clear(); mLoadedMotions.clear(); mActiveMotions.clear(); //<singu> mActiveMask = 0; for_each(mDeprecatedMotions.begin(), mDeprecatedMotions.end(), DeletePointer()); mDeprecatedMotions.clear(); for (motion_map_t::iterator iter = mAllMotions.begin(); iter != mAllMotions.end(); ++iter) { iter->second->unregister_client(); } //</singu> for_each(mAllMotions.begin(), mAllMotions.end(), DeletePairedPointer()); mAllMotions.clear(); }
// virtual LLFloaterReporter::~LLFloaterReporter() { // child views automatically deleted mObjectID = LLUUID::null; if (mPicking) { closePickTool(this); } mPosition.setVec(0.0f, 0.0f, 0.0f); std::for_each(mMCDList.begin(), mMCDList.end(), DeletePointer() ); mMCDList.clear(); delete mResourceDatap; }
void LLCurl::Multi::cleanup(bool deleted) { if(!mCurlMultiHandle) { return ; //nothing to clean. } llassert_always(deleted || !mValid) ; LLMutexLock lock(mDeletionMutexp); // Clean up active for(easy_active_list_t::iterator iter = mEasyActiveList.begin(); iter != mEasyActiveList.end(); ++iter) { Easy* easy = *iter; check_curl_multi_code(curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle())); if(deleted) { easy->mResponder = NULL ; //avoid triggering mResponder. } delete easy; } mEasyActiveList.clear(); mEasyActiveMap.clear(); // Clean up freed for_each(mEasyFreeList.begin(), mEasyFreeList.end(), DeletePointer()); mEasyFreeList.clear(); check_curl_multi_code(LLCurl::deleteMultiHandle(mCurlMultiHandle)); mCurlMultiHandle = NULL ; delete mMutexp ; mMutexp = NULL ; delete mEasyMutexp ; mEasyMutexp = NULL ; mQueued = 0 ; mState = STATE_COMPLETED; --gCurlMultiCount; return ; }
// virtual LLFloaterReporter::~LLFloaterReporter() { gReporterInstances.removeData(mReportType); // child views automatically deleted mObjectID = LLUUID::null; if (mPicking) { closePickTool(this); } mPosition.setVec(0.0f, 0.0f, 0.0f); std::for_each(mMCDList.begin(), mMCDList.end(), DeletePointer() ); mMCDList.clear(); delete mResourceDatap; gDialogVisible = FALSE; }
void LLXferManager::updateHostStatus() { LLXfer *xferp; LLHostStatus *host_statusp = NULL; for_each(mOutgoingHosts.begin(), mOutgoingHosts.end(), DeletePointer()); mOutgoingHosts.clear(); for (xferp = mSendList; xferp; xferp = xferp->mNext) { for (status_list_t::iterator iter = mOutgoingHosts.begin(); iter != mOutgoingHosts.end(); ++iter) { host_statusp = *iter; if (host_statusp->mHost == xferp->mRemoteHost) { break; } } if (!host_statusp) { host_statusp = new LLHostStatus(); if (host_statusp) { host_statusp->mHost = xferp->mRemoteHost; mOutgoingHosts.push_front(host_statusp); } } if (host_statusp) { if (xferp->mStatus == e_LL_XFER_PENDING) { host_statusp->mNumPending++; } else if (xferp->mStatus == e_LL_XFER_IN_PROGRESS) { host_statusp->mNumActive++; } } } }
LLCurl::Multi::~Multi() { // Clean up active for(easy_active_list_t::iterator iter = mEasyActiveList.begin(); iter != mEasyActiveList.end(); ++iter) { Easy* easy = *iter; curl_multi_remove_handle(mCurlMultiHandle, easy->getCurlHandle()); delete easy; } mEasyActiveList.clear(); mEasyActiveMap.clear(); // Clean up freed for_each(mEasyFreeList.begin(), mEasyFreeList.end(), DeletePointer()); mEasyFreeList.clear(); curl_multi_cleanup(mCurlMultiHandle); --gCurlMultiCount; }
void LLDrawable::cleanupReferences() { LLFastTimer t(FTM_CLEANUP_DRAWABLE); { LLFastTimer t(FTM_DELETE_FACES); std::for_each(mFaces.begin(), mFaces.end(), DeletePointer()); mFaces.clear(); } gObjectList.removeDrawable(this); gPipeline.unlinkDrawable(this); { LLFastTimer t(FTM_DEREF_DRAWABLE); // Cleanup references to other objects mVObjp = NULL; mParent = NULL; } }
void LLTabContainer::deleteAllTabs() { // Remove all the tab buttons and delete them. Also, unlink all the child panels. for(std::vector<LLTabTuple*>::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter) { LLTabTuple* tuple = *iter; removeChild( tuple->mButton ); delete tuple->mButton; removeChild( tuple->mTabPanel ); // delete tuple->mTabPanel; } // Actually delete the tuples themselves std::for_each(mTabList.begin(), mTabList.end(), DeletePointer()); mTabList.clear(); // And there isn't a current tab any more mCurrentTabIdx = -1; }