//-------------------------------------------------------------------- // // CCPoolManager // //--------------------------------------------------------------------
/////【diff - begin】- by layne//////
CCPoolManager* CCPoolManager::sharedPoolManager() { if (s_pPoolManager == NULL) { s_pPoolManager = new CCPoolManager(); } return s_pPoolManager; }
void CCPoolManager::purgePoolManager() { CC_SAFE_DELETE(s_pPoolManager); }
CCPoolManager::CCPoolManager() { // m_pReleasePoolStack = new CCArray(); // m_pReleasePoolStack->init(); // m_pCurReleasePool = 0;
m_pReleasePoolMultiStack = new CCDictionary(); }
CCPoolManager::~CCPoolManager() {
// finalize();
// // we only release the last autorelease pool here // m_pCurReleasePool = 0; // m_pReleasePoolStack->removeObjectAtIndex(0); // // CC_SAFE_DELETE(m_pReleasePoolStack);
finalize();
CC_SAFE_DELETE(m_pReleasePoolMultiStack); }
void CCPoolManager::finalize() { if(m_pReleasePoolMultiStack->count() > 0) { //CCAutoreleasePool* pReleasePool; CCObject* pkey = NULL; CCARRAY_FOREACH(m_pReleasePoolMultiStack->allKeys(), pkey) { if(!pkey) break; CCInteger *key = (CCInteger*)pkey; CCArray *poolStack = (CCArray *)m_pReleasePoolMultiStack->objectForKey(key->getValue()); CCObject* pObj = NULL; CCARRAY_FOREACH(poolStack, pObj) { if(!pObj) break; CCAutoreleasePool* pPool = (CCAutoreleasePool*)pObj; pPool->clear(); } } } }
void CCPoolManager::push() { // CCAutoreleasePool* pPool = new CCAutoreleasePool(); //ref = 1 // m_pCurReleasePool = pPool; // // m_pReleasePoolStack->addObject(pPool); //ref = 2 // // pPool->release(); //ref = 1
pthread_mutex_lock(&m_mutex);
CCArray* pCurReleasePoolStack = getCurReleasePoolStack(); CCAutoreleasePool* pPool = new CCAutoreleasePool(); //ref = 1 pCurReleasePoolStack->addObject(pPool); //ref = 2 pPool->release(); //ref = 1
pthread_mutex_unlock(&m_mutex); }
void CCPoolManager::pop() { // if (! m_pCurReleasePool) // { // return; // } // // int nCount = m_pReleasePoolStack->count(); // // m_pCurReleasePool->clear(); // // if(nCount > 1) // { // m_pReleasePoolStack->removeObjectAtIndex(nCount-1); // // // if(nCount > 1) // // { // // m_pCurReleasePool = m_pReleasePoolStack->objectAtIndex(nCount - 2); // // return; // // } // m_pCurReleasePool = (CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount - 2); // } // // /*m_pCurReleasePool = NULL;*/
pthread_mutex_lock(&m_mutex);
CCArray* pCurReleasePoolStack = getCurReleasePoolStack(); CCAutoreleasePool* pCurReleasePool = getCurReleasePool(); if (pCurReleasePoolStack && pCurReleasePool) { int nCount = pCurReleasePoolStack->count();
pCurReleasePool->clear();
if(nCount > 1) { pCurReleasePoolStack->removeObject(pCurReleasePool); } }
pthread_mutex_unlock(&m_mutex); }
void CCPoolManager::removeObject(CCObject* pObject) { // CCAssert(m_pCurReleasePool, "current auto release pool should not be null"); // // m_pCurReleasePool->removeObject(pObject);
pthread_mutex_lock(&m_mutex); CCAutoreleasePool* pCurReleasePool = getCurReleasePool(); CCAssert(pCurReleasePool, "current auto release pool should not be null");
pCurReleasePool->removeObject(pObject); pthread_mutex_unlock(&m_mutex); }
void CCPoolManager::addObject(CCObject* pObject) { // getCurReleasePool()->addObject(pObject);
pthread_mutex_lock(&m_mutex); CCAutoreleasePool* pCurReleasePool = getCurReleasePool(true); CCAssert(pCurReleasePool, "current auto release pool should not be null");
pCurReleasePool->addObject(pObject); pthread_mutex_unlock(&m_mutex); }
CCArray* CCPoolManager::getCurReleasePoolStack() { CCArray* pPoolStack = NULL; pthread_t tid = pthread_self(); if(m_pReleasePoolMultiStack->count() > 0) { pPoolStack = (CCArray*)m_pReleasePoolMultiStack->objectForKey((int)tid); }
if (!pPoolStack) { pPoolStack = new CCArray(); m_pReleasePoolMultiStack->setObject(pPoolStack, (int)tid); pPoolStack->release(); }
return pPoolStack; }
CCAutoreleasePool* CCPoolManager::getCurReleasePool(bool autoCreate) { // if(!m_pCurReleasePool) // { // push(); // } // // CCAssert(m_pCurReleasePool, "current auto release pool should not be null"); // // return m_pCurReleasePool;
CCAutoreleasePool* pReleasePool = NULL;
CCArray* pPoolStack = getCurReleasePoolStack(); if(pPoolStack->count() > 0) { pReleasePool = (CCAutoreleasePool*)pPoolStack->lastObject(); }
if (!pReleasePool && autoCreate) { CCAutoreleasePool* pPool = new CCAutoreleasePool(); //ref = 1 pPoolStack->addObject(pPool); //ref = 2 pPool->release(); //ref = 1
pReleasePool = pPool; }
return pReleasePool; }
/////【diff - end】- by layne////// |