/// The resource should put a description of itself (number of vertices, size/width of texture, etc.) in buffer const String GFXPrimitiveBuffer::describeSelf() const { #if defined(TORQUE_DEBUG) && defined(TORQUE_ENABLE_PROFILER) return String::ToString("indexCount: %6d primCount: %6d refCount: %d path: %s", mIndexCount, mPrimitiveCount, getRefCount(), mDebugCreationPath.c_str()); #else return String::ToString("indexCount: %6d primCount: %6d refCount: %d path: %s", mIndexCount, mPrimitiveCount, getRefCount(), ""); #endif }
void Client::releaseConfig(Config* config) { _impl->server->releaseConfig(config); if (!disconnectServer(_impl->server)) LBERROR << "Client::disconnectServer failed" << std::endl; _impl->server = 0; exitLocal(); LBASSERTINFO(getRefCount() == 1, "Client still referenced by " << getRefCount() - 1); }
Animation::Animation(const char* id, AnimationTarget* target, int propertyId, unsigned int keyCount, unsigned long* keyTimes, float* keyValues, float* keyInValue, float* keyOutValue, unsigned int type) : _controller(Game::getInstance()->getAnimationController()), _id(id), _duration(0), _defaultClip(NULL), _clips(NULL) { createChannel(target, propertyId, keyCount, keyTimes, keyValues, keyInValue, keyOutValue, type); // Release the animation because a newly created animation has a ref count of 1 and the channels hold the ref to animation. release(); assert(getRefCount() == 1); }
bool Object :: remove() { if(getRefCount() < 2) { LOG_DEBUG("%s: Remove destructor id - %i", getClassName(), getId()); delete this; return true; } return false; }
//============================================================================== AutoPtr<SynchronizedObject> Writer::getLock() const { // Note: As we are returning a AutoPtr, it is imperative that // our reference count is not zero if the lock is pointing // at this object SynchronizedObject* pLock = m_rpLock; QC_DBG_ASSERT((Writer*) pLock != this || getRefCount()); return pLock; }
void IndexFileDeleter::incRef(const vector<string>& files) { int32_t size = files.size(); for(int32_t i=0;i<size;i++) { const string& fileName = files[i]; RefCount* rc = getRefCount(fileName.c_str()); if (infoStream != NULL && VERBOSE_REF_COUNTS) { message(string(" IncRef \"") + fileName + "\": pre-incr count is " + Misc::toString((int32_t)rc->count)); } rc->IncRef(); } }
void Client::exitClient() { _impl->queue.flush(); bool ret = exitLocal(); LBINFO << "Exit " << lunchbox::className( this ) << " process used " << getRefCount() << std::endl; if( !eq::exit( )) ret = false; ::exit( ret ? EXIT_SUCCESS : EXIT_FAILURE ); }
void IndexFileDeleter::decRef(const string& fileName) { RefCount* rc = getRefCount(fileName.c_str()); if (infoStream != NULL && VERBOSE_REF_COUNTS) { message(string(" DecRef \"") + fileName + "\": pre-decr count is " + Misc::toString((int32_t)rc->count)); } if (0 == rc->DecRef()) { // This file is no int32_t64_ter referenced by any past // commit point32_ts nor by the in-memory SegmentInfos: deleteFile(fileName.c_str()); refCounts.remove((char*)fileName.c_str()); } }
/**************************************************************************** Desc: Get a new block using an exising or newly allocated block from the cache. Initializes the block. May be leaf or non-leaf but NOT the root block. ****************************************************************************/ RCODE F_BtreeRoot::newBlk( F_BtreeBlk ** ppBlk, eDynRSetBlkTypes eBlkType) { RCODE rc = NE_FLM_OK; FLMUINT uiLRUValue = (FLMUINT)~0; FLMUINT uiPos; FLMUINT uiLRUPos = 0; F_BtreeBlk * pNewBlk; for (uiPos = 0; uiPos < FBTREE_CACHE_BLKS; uiPos++) { // The ref count is used for pinning the block. if (getRefCount() == 1 && uiLRUValue > m_CacheBlks[uiPos].uiLRUValue) { uiLRUValue = m_CacheBlks[uiPos].uiLRUValue; uiLRUPos = uiPos; } // use the first hole. if (m_CacheBlks[uiPos].pBlk == NULL) { uiLRUPos = uiPos; break; } } uiPos = uiLRUPos; if (RC_BAD( rc = newCacheBlk( uiPos, &pNewBlk, eBlkType))) { goto Exit; } pNewBlk->blkAddr( newBlkAddr()); m_CacheBlks[uiPos].uiBlkAddr = pNewBlk->blkAddr(); m_CacheBlks[uiPos].uiLRUValue = m_uiLRUCount++; pNewBlk->entryCount(0); pNewBlk->lemBlk( FBTREE_END); pNewBlk->nextBlk( FBTREE_END); pNewBlk->prevBlk( FBTREE_END); *ppBlk = pNewBlk; Exit: return( rc); }
void IndexFileDeleter::incRef(SegmentInfos* segmentInfos, bool isCommit) { int32_t size = segmentInfos->size(); for(int32_t i=0;i<size;i++) { SegmentInfo* segmentInfo = segmentInfos->info(i); if (segmentInfo->dir == directory) { incRef(segmentInfo->files()); } } if (isCommit) { // Since this is a commit point32_t, also incref its // segments_N file: getRefCount(segmentInfos->getCurrentSegmentFileName().c_str())->IncRef(); } }
int32 String::checkToClearAndAlloc(int32 nNewLength) { if (getRefCount() <= 1) { internalAlloc(nNewLength); } else { release(); internalAlloc(nNewLength); } return nNewLength; }
IpcMessageRefCount CmpMessageObj::decrRefCount() { if (getRefCount()==1) { if (h_) { destroyMe(); h_->deallocateMemory(this); } else delete this; return 0; } return IpcMessageObj::decrRefCount(); }
IpcMessageRefCount ExEspMsgObj::decrRefCount() { if (getRefCount() == 1) { // IpcMessageObj::decrRefCount() would delete the object by calling // global operator delete (since IpcMessageObj doesn't have an // operator delete). However, if we code the "delete this" statement // in this context we will pick up the correct operator delete. delete this; return 0; } else { // normal case, object won't be deleted return IpcMessageObj::decrRefCount(); } }
bool Application::exit() { bool retVal = true; if( _impl ) retVal = _impl->exit(); if( !exitLocal( )) retVal = false; if( !eq::exit( )) retVal = false; exitErrors(); delete _impl; _impl = 0; LBASSERTINFO( getRefCount() == 1, this->getRefCount( )); return retVal; }
int32 String::checkToCopyAndAlloc(int32 nNewLength) { if (getRefCount() <= 1) { internalAlloc(nNewLength); } else { XCHAR * pStrOld = m_pString; int32 nOldLength = getLength(); release(); internalAlloc(nNewLength); xMemoryCopy(m_pString, pStrOld, sizeof(XCHAR)*nOldLength); } return nNewLength; }
IndexFileDeleter::IndexFileDeleter(Directory* directory, IndexDeletionPolicy* policy, SegmentInfos* segmentInfos, std::ostream* infoStream, DocumentsWriter* docWriter): refCounts( RefCountsType(true,true) ), commits(CommitsType(true)) { this->docWriter = docWriter; this->infoStream = infoStream; if (infoStream != NULL) message( string("init: current segments file is \"") + segmentInfos->getCurrentSegmentFileName() + "\"; deletionPolicy=" + policy->getObjectName()); this->policy = policy; this->directory = directory; CommitPoint* currentCommitPoint = NULL; // First pass: walk the files and initialize our ref // counts: int64_t currentGen = segmentInfos->getGeneration(); const IndexFileNameFilter* filter = IndexFileNameFilter::getFilter(); vector<string> files; if ( !directory->list(&files) ) _CLTHROWA(CL_ERR_IO, (string("cannot read directory ") + directory->toString() + ": list() returned NULL").c_str()); for(size_t i=0;i<files.size();i++) { string& fileName = files.at(i); if (filter->accept(NULL, fileName.c_str()) && fileName.compare(IndexFileNames::SEGMENTS_GEN) != 0) { // Add this file to refCounts with initial count 0: getRefCount(fileName.c_str()); if ( strncmp(fileName.c_str(), IndexFileNames::SEGMENTS, strlen(IndexFileNames::SEGMENTS)) == 0 ) { // This is a commit (segments or segments_N), and // it's valid (<= the max gen). Load it, then // incref all files it refers to: if (SegmentInfos::generationFromSegmentsFileName(fileName.c_str()) <= currentGen) { if (infoStream != NULL) { message("init: load commit \"" + fileName + "\""); } SegmentInfos sis; bool failed = false; try { sis.read(directory, fileName.c_str()); } catch (CLuceneError& e) { if ( e.number() != CL_ERR_IO ){ throw e; } // LUCENE-948: on NFS (and maybe others), if // you have writers switching back and forth // between machines, it's very likely that the // dir listing will be stale and will claim a // file segments_X exists when in fact it // doesn't. So, we catch this and handle it // as if the file does not exist if (infoStream != NULL) { message("init: hit FileNotFoundException when loading commit \"" + fileName + "\"; skipping this commit point32_t"); } failed = true; } if (!failed) { CommitPoint* commitPoint = _CLNEW CommitPoint(this,&sis); if (sis.getGeneration() == segmentInfos->getGeneration()) { currentCommitPoint = commitPoint; } commits.push_back(commitPoint); incRef(&sis, true); } } } } } if (currentCommitPoint == NULL) { // We did not in fact see the segments_N file // corresponding to the segmentInfos that was passed // in. Yet, it must exist, because our caller holds // the write lock. This can happen when the directory // listing was stale (eg when index accessed via NFS // client with stale directory listing cache). So we // try now to explicitly open this commit point32_t: SegmentInfos sis; try { sis.read(directory, segmentInfos->getCurrentSegmentFileName().c_str()); } catch (CLuceneError& e) { if ( e.number() == CL_ERR_IO ){ _CLTHROWA(CL_ERR_CorruptIndex, "failed to locate current segments_N file"); } } if (infoStream != NULL) message("forced open of current segments file " + segmentInfos->getCurrentSegmentFileName()); currentCommitPoint = _CLNEW CommitPoint(this,&sis); commits.push_back(currentCommitPoint); incRef(&sis, true); } // We keep commits list in sorted order (oldest to newest): std::sort(commits.begin(), commits.end(), CommitPoint::sort); // Now delete anything with ref count at 0. These are // presumably abandoned files eg due to crash of // IndexWriter. RefCountsType::iterator it = refCounts.begin(); while(it != refCounts.end()) { char* fileName = it->first; RefCount* rc = it->second; if (0 == rc->count) { if (infoStream != NULL) { message( string("init: removing unreferenced file \"") + fileName + "\""); } deleteFile(fileName); } it++; } // Finally, give policy a chance to remove things on // startup: policy->onInit(commits); // It's OK for the onInit to remove the current commit // point; we just have to checkpoint our in-memory // SegmentInfos to protect those files that it uses: if (currentCommitPoint->deleted) { checkpoint(segmentInfos, false); } deleteCommits(); }
void SharedObject::deleteIfZeroRefCount() const { if(getRefCount() == 0) { delete this; } }
void Texture::init() { if ( texturaCarregada == false ) { if (pathFile.compare("FRAME_BUFFER") != 0) { SDL_Surface *pImage = IMG_Load ( pathFile.c_str() ); if ( pImage == nullptr ) throw ExceptionChimera ( ExceptionCode::READ, "Falha ao ler arquivo:" + pathFile ); // Create The Texture glGenTextures ( 1, ( GLuint* ) &idTexture); // Load in texture glBindTexture ( GL_TEXTURE_2D, idTexture ); // Typical Texture Generation Using Data From The Bitmap height = pImage->h; width = pImage->w; // Generate The Texture if ( pImage->format->Amask != 0 ) { glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGBA, pImage->w, pImage->h, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, pImage->pixels ); } else { glTexImage2D ( GL_TEXTURE_2D, 0, GL_RGBA, pImage->w, pImage->h, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, pImage->pixels ); } // Nearest Filtering glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); SDL_FreeSurface ( pImage ); } else { glBindTexture(GL_TEXTURE_2D, idTexture); glGenFramebuffers(1, &depthMapFBO); glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, idTexture, 0); glDrawBuffer(GL_NONE); glReadBuffer(GL_NONE); glBindFramebuffer(GL_FRAMEBUFFER, 0); } texturaCarregada = true; printf("Texture Name: %s id: %u num instancia: %d\n", getName().c_str(), idTexture, getRefCount()); } }
void simpRecord::decrementRefCount(){ rec->refCount = getRefCount()-1; // return(rec->refCount); }