void verifyList(Entry *e){
	Entry *volatile prev=NULL;
	while(e!=NULL){
		if(!is_marked(e)){
			clearDebugging();
			B(prev);
		}
		prev=e;
		e=clearDeleted(e->nextEntry);
	}
}
//For debugging
int Count(HashMap *hash){
	int cnt=0;
	for(int i=0; i<hash->len; ++i)
	{
		Entry *head = hash->array[i];
		while(head!=NULL){
			cnt++;
			head=clearDeleted( head->nextEntry);
		}
	}
	return cnt;
}
bool find(LinkedList *entryHead, Entry ***outprev, Entry **outcur, int key) {
	int ckey;
	Entry **prev, *cur, *next;

	try_again:
	prev = &entryHead->head;
	cur = *(prev);

	while (cur != NULL) {
		next = cur->nextEntry;

		if(isDeleted(next)) {
			if (!CAS(prev, cur, clearDeleted(next)))
				goto try_again; 		// disconnect of the deleted entry failed, try again

			cur = clearDeleted(next);
		} else {
			ckey = cur->key;

			if (*(prev) != cur) {
				goto try_again;
			}

			if (ckey >= key) {
				*outprev = prev;
				*outcur	 = cur;
				return (ckey == key); 	//compare search key
			}

			prev = &(cur->nextEntry);
			cur = next;
		}
	} //end of while
	*outprev=prev;
	*outcur=cur;
	return false;
}
Beispiel #4
0
ResourceManager::~ResourceManager()
{
    mDestruction = true;
    mResources.insert(mOrphanedResources.begin(), mOrphanedResources.end());

    // Release any remaining spritedefs first because they depend on image sets
    ResourceIterator iter = mResources.begin();

#ifdef DEBUG_LEAKS
#ifdef UNITTESTS
    bool status(false);
#endif  // UNITTESTS

    while (iter != mResources.end())
    {
        if (iter->second)
        {
            if (iter->second->getRefCount())
            {
                logger->log(std::string("ResourceLeak: ").append(
                    iter->second->getIdPath()).append(" (").append(
                    toString(iter->second->getRefCount())).append(")"));
#ifdef UNITTESTS
                status = true;
#endif  // UNITTESTS
            }
        }
        ++iter;
    }

#ifdef UNITTESTS
    if (status)
        reportAlways("Found leaked resources.");
#endif  // UNITTESTS

    iter = mResources.begin();
#endif  // DEBUG_LEAKS

    while (iter != mResources.end())
    {
#ifdef DEBUG_LEAKS
        if (iter->second && iter->second->getRefCount())
        {
            ++iter;
            continue;
        }
#endif  // DEBUG_LEAKS

        if (dynamic_cast<SpriteDef*>(iter->second))
        {
            cleanUp(iter->second);
            const ResourceIterator toErase = iter;
            ++iter;
            mResources.erase(toErase);
        }
        else
        {
            ++iter;
        }
    }

    // Release any remaining image sets first because they depend on images
    iter = mResources.begin();
    while (iter != mResources.end())
    {
#ifdef DEBUG_LEAKS
        if (iter->second && iter->second->getRefCount())
        {
            ++iter;
            continue;
        }
#endif  // DEBUG_LEAKS

        if (dynamic_cast<ImageSet*>(iter->second))
        {
            cleanUp(iter->second);
            const ResourceIterator toErase = iter;
            ++iter;
            mResources.erase(toErase);
        }
        else
        {
            ++iter;
        }
    }

    // Release remaining resources, logging the number of dangling references.
    iter = mResources.begin();
    while (iter != mResources.end())
    {
#ifdef DEBUG_LEAKS
        if (iter->second && iter->second->getRefCount())
        {
            ++iter;
            continue;
        }
#endif  // DEBUG_LEAKS

        if (iter->second)
        {
            cleanUp(iter->second);
            const ResourceIterator toErase = iter;
            ++iter;
            mResources.erase(toErase);
        }
        else
        {
            ++iter;
        }
    }
    clearDeleted();
    clearScheduled();
}