自学教程：C++ CoreAssert函数代码示例

		void Profiler::EndProfile(char const *_name)		{			CoreAssert(this != NULL);			if (!IsMasterThread()) return;			//CoreAssert(m_currentElement->m_wasExpanded == m_currentElement->m_parent->m_isExpanded);			if (m_currentElement &&				m_currentElement->m_parent )			{				if (m_currentElement->m_parent->m_isExpanded) {					if (m_doGlFinish && m_inRenderSection) {#ifdef ENABLE_OPENGL						glFinish();#endif					}					CoreAssert(m_currentElement != m_rootElement);					CoreAssert(CrissCross::Data::Compare(_name, (const char *)m_currentElement->m_name) == 0);					m_currentElement->End();				}				CoreAssert(CrissCross::Data::Compare(m_currentElement->m_name, m_currentElement->m_parent->m_name) != 0);				m_currentElement = m_currentElement->m_parent;			}		}

		int64_t CoreIOReader::Position()		{			CoreAssert(this != NULL);			CoreAssert(IsOpen());#ifdef HAS_FPOS64			fpos64_t lastpos;#if defined(TARGET_COMPILER_VC) || defined(TARGET_COMPILER_BORLAND) || /	(defined(TARGET_COMPILER_ICC) && defined(TARGET_OS_WINDOWS))			lastpos = _ftelli64(m_fileInputPointer);			return lastpos;#elif defined (TARGET_OS_MACOSX) || defined (TARGET_OS_NETBSD) || /	  defined (TARGET_OS_FREEBSD) || defined (TARGET_OS_OPENBSD) || /      defined (TARGET_COMPILER_MINGW)			fgetpos(m_fileInputPointer, &lastpos);			return lastpos;#else			fgetpos64(m_fileInputPointer, &lastpos);			return lastpos.__pos;#endif#else			fpos_t lastpos;			lastpos = ftell(m_fileInputPointer);			return lastpos;#endif		}

Uint32 OpenGLGraphics::CreateFont(const char *_fontFace, int _height, bool _bold, bool _italic){#ifdef ENABLE_FONTS	char fontpath[512];	MemMappedFile *file = NULL;	sprintf(fontpath, "fonts/%s.ttf", _fontFace);	file = g_app->m_resource->GetUncompressedFile(fontpath);	if ( !file ) {#ifdef TARGET_OS_WINDOWS		char windir[128];		GetWindowsDirectory(windir, 128);		sprintf(fontpath, "%s/fonts/%s.ttf", windir, _fontFace);#elif defined(TARGET_OS_MACOSX)		sprintf(fontpath, "/Library/Fonts/%s.ttf", windir, _fontFace);#endif		file = g_app->m_resource->GetUncompressedFile(fontpath);	}	CoreAssert(file);	OpenGLFont *font = new OpenGLFont(file->m_data, file->m_size);	CoreAssert(font);	font->SetFontSize(_height);	font->SetBold(_italic);	font->SetItalic(_italic);	return m_fonts.insert(font);#else	return 0;#endif}

		Mutex::Mutex(MutexType _type)			: m_type(_type)		{			m_lockCount = 0;#ifdef TARGET_OS_WINDOWS			InitializeCriticalSection(&m_mutex);#else			int error;			error = pthread_mutexattr_init(&m_mutexAttr);			CoreAssert(error == 0);			int ptype = 0;			switch (m_type)			{			case MUTEX_TYPE_NORMAL:				ptype = PTHREAD_MUTEX_NORMAL;				break;			case MUTEX_TYPE_ERRORCHECK:				ptype = PTHREAD_MUTEX_ERRORCHECK;				break;			case MUTEX_TYPE_RECURSIVE:			default:				ptype = PTHREAD_MUTEX_RECURSIVE;				break;			}			error = pthread_mutexattr_settype(&m_mutexAttr, ptype);			CoreAssert(error == 0);			error = pthread_mutex_init(&m_mutex, &m_mutexAttr);			CoreAssert(error == 0);#endif		}

		void Mutex::Lock()		{			CoreAssert(this != NULL);#ifdef TARGET_OS_WINDOWS			EnterCriticalSection(&m_mutex);#else			int error = pthread_mutex_lock(&m_mutex);			CoreAssert(error == 0);#endif			m_lockCount++;		}

		Mutex::Mutex()		{			m_lockCount = 0;#ifdef TARGET_OS_WINDOWS			InitializeCriticalSection(&m_criticalSection);#else			int error;			error = pthread_mutexattr_init(&m_mutexAttr);			CoreAssert(error == 0);			error = pthread_mutexattr_settype(&m_mutexAttr, PTHREAD_MUTEX_RECURSIVE);			CoreAssert(error == 0);			error = pthread_mutex_init(&m_hMutex, &m_mutexAttr);			CoreAssert(error == 0);#endif		}

		CrissCross::Errors CoreIOWriter::Write(const char *_format, ...)		{			CoreAssert(this != NULL);			if (!IsOpen()) return CC_ERR_INVALID_BUFFER;			if (_format == NULL)				return CC_ERR_BADPARAMETER;#ifndef __GNUC__			MutexHolder mh(&m_ioMutex);#endif			va_list args;			va_start(args, _format);			/* Print out the string */			if (vfprintf(m_fileOutputPointer, _format, args) < 0)				return CC_ERR_WRITE;			fflush(m_fileOutputPointer);			va_end(args);			return CC_ERR_NONE;		}

void CPUID::DetectCacheInfo(int processor){    CoreAssert(this != NULL);    if (proc[processor]->Manufacturer) {        if (strcmp(proc[processor]->Manufacturer, "GenuineIntel") == 0)	{            int ntlb = 255, i;            for (i = 0; i < ntlb; i++) {                ntlb = Std[2].eax & 0xff;                AddIntelCacheData(processor, Std[2].eax >> 8);                AddIntelCacheData(processor, Std[2].eax >> 16);                AddIntelCacheData(processor, Std[2].eax >> 24);                if ((Std[2].ebx & 0x80000000) == 0) {                    AddIntelCacheData(processor, Std[2].ebx);                    AddIntelCacheData(processor, Std[2].ebx >> 8);                    AddIntelCacheData(processor, Std[2].ebx >> 16);                    AddIntelCacheData(processor, Std[2].ebx >> 24);                }                if ((Std[2].ecx & 0x80000000) == 0) {                    AddIntelCacheData(processor, Std[2].ecx);                    AddIntelCacheData(processor, Std[2].ecx >> 8);                    AddIntelCacheData(processor, Std[2].ecx >> 16);                    AddIntelCacheData(processor, Std[2].ecx >> 24);                }                if ((Std[2].edx & 0x80000000) == 0) {                    AddIntelCacheData(processor, Std[2].edx);                    AddIntelCacheData(processor, Std[2].edx >> 8);                    AddIntelCacheData(processor, Std[2].edx >> 16);                    AddIntelCacheData(processor, Std[2].edx >> 24);                }

		bool SortingHashTable<T>::erase(size_t _index)		{			bool retval = false;			/* */			/* Remove data */			if (this->m_keys[_index] != (char *)-1) {				retval = true;				delete [] this->m_keys[_index];			}			this->m_keys[_index] = (char *)-1;			this->m_slotsFree++;			/* */			/* Remove from ordered list */			short prevIndex = -1;			short index = m_firstOrderedIndex;			while (m_orderedIndices[index] != _index)			{				CoreAssert(index != -1);				prevIndex = index;				index = m_orderedIndices[index];			}			if (prevIndex == -1) {				m_firstOrderedIndex = -1;			} else	{				m_orderedIndices[prevIndex] = m_orderedIndices[index];			}			return retval;		}

		CrissCross::Errors CoreIOWriter::WriteLine(const char *_format, ...)		{			CoreAssert(this != NULL);			if (!IsOpen()) return CC_ERR_INVALID_BUFFER;			if (_format == NULL)				return CC_ERR_BADPARAMETER;#ifndef __GNUC__			m_ioMutex.Lock();#endif			va_list args;			va_start(args, _format);			/* Print out the string */			vfprintf(m_fileOutputPointer, _format, args);			if (fprintf(m_fileOutputPointer, "%s", m_lineEnding) < 0)				return CC_ERR_WRITE;			va_end(args);			Flush();#ifndef __GNUC__			m_ioMutex.Unlock();#endif			return CC_ERR_NONE;		}

/* * Read a directory entry, and return a pointer to a dirent structure * containing the name of the entry in d_name field.  Individual directory * entries returned by this very function include regular files, * sub-directories, pseudo-directories "." and "..", but also volume labels, * hidden files and system files may be returned. */struct dirent *readdir(DIR *dirp){	CoreAssert(dirp);	if (dirp->search_handle == INVALID_HANDLE_VALUE) {		/* directory stream was opened/rewound incorrectly or it ended normally */		return NULL;	}	/* get next directory entry */	if (dirp->cached != 0) {		/* a valid directory entry already in memory */		dirp->cached = 0;	} else {		/* read next directory entry from disk */		if (FindNextFileA(dirp->search_handle, &dirp->current.data) == FALSE) {			/* the very last file has been processed or an error occured */			FindClose(dirp->search_handle);			dirp->search_handle = INVALID_HANDLE_VALUE;			return NULL;		}	}	/* copy as a multibyte character string */	strncpy(dirp->current.d_name, dirp->current.data.cFileName, sizeof(dirp->current.d_name));	dirp->current.d_name[MAX_PATH] = '/0';	return &dirp->current;}

		CrissCross::Errors FileReader::Open(const char *_file)		{			CoreAssert(this != NULL);			Close();			int _filePathLength = 0;			if (_file == NULL)				return CC_ERR_BADPARAMETER;			if ((_filePathLength = (int)strlen(_file)) < 1)				return CC_ERR_BADPARAMETER;			delete [] (char *)m_filePath;			m_filePath = new char[_filePathLength + 1];			strcpy((char *)m_filePath, _file);			m_fileInputPointer = fopen(m_filePath, "rb");			if (m_fileInputPointer == NULL)				return CC_ERR_FILE_OPEN;			else				return CC_ERR_NONE;		}

		RWLockHolder::RWLockHolder(ReadWriteLock *_lock, RWLockHolderType _type)			: m_lock(_lock), m_type(_type), m_copied(false)		{			CoreAssert(_lock);			switch(_type)			{			case RW_LOCK_READ:				m_lock->LockRead();				break;			case RW_LOCK_WRITE:				m_lock->LockWrite();				break;			default:				CoreAssert(_type != RW_LOCK_READ && _type != RW_LOCK_WRITE);			}		}

		size_t SortingHashTable<T>::insert(char const *_key, T const &_data)		{			/* */			/* Make sure the table is big enough */			if (this->m_slotsFree * 2 <= this->m_size) {				grow();			}			/* */			/* Do the main insert */			size_t index = HashTable<T>::findInsertIndex(_key);			CoreAssert(this->m_keys[index] == NULL || this->m_keys[index] == (char*)-1);			this->m_keys[index] = cc_strdup(_key);			this->m_data[index] = _data;			this->m_slotsFree--;			/* */			/* Insert us into the alphabetically order index list */			size_t i = findPrevKey(_key);			if (i == -1) {				/* Handle the case when the table is empty, or the new element is going */				/* to be the new first alphabetical element */				m_orderedIndices[index] = m_firstOrderedIndex;				m_firstOrderedIndex = index;			} else	{				m_orderedIndices[index] = m_orderedIndices[i];				m_orderedIndices[i] = index;			}			return index;		}

		void TigerHash::Reset()		{			CoreAssert(this != NULL);			delete [] m_hash; m_hash = NULL;			delete [] m_hashString; m_hashString = NULL;			tiger_init(&m_state);		}