C++ StdString::MakeSafeFileName方法代码示例

/// \brief	message handler to create zipped memory stream
/// \param	size - size of LPCTSTR
/// \param	param - pointer to string with path
/// \return	EE message return code
DWORD CZLibStreamFactory::OnAddZipFile(DWORD size, void *param)
{
	VERIFY_MESSAGE_SIZE(size, sizeof(LPCTSTR));
	StdString sPath = static_cast<LPCTSTR>(param);
	sPath.MakeSafeFileName();
	//sPath.ConformSlashesForward();
	if (!CZipFileStream::AddSearchPath(sPath.c_str()))
	{
		return MSG_ERROR;
	}
	return MSG_HANDLED_STOP;
}

///	removes previous state machine mapping to file and adds new one
///	\param	stateMachine - pointer to state machine to map
///	\param	fileName - current file name for state machine
///	\param	oldFileName - old mapping file name. This value may be NULL
void CQHStateMachineManager::MapStateMachineToFileName( IObject *stateMachine, 
														IHashString *fileName, 
														IHashString *oldFileName )
{
	if( oldFileName != NULL && !oldFileName->IsEmpty() && oldFileName->GetString() != NULL )
	{
		StdString oldFile = oldFileName->GetString();
		oldFile.MakeSafeFileName();
		CHashString safeOldFileName( oldFile );

		m_StateMachineToFileName.erase( stateMachine->GetName()->GetUniqueID() );
		m_FilenameToStateMachine.erase( safeOldFileName.GetUniqueID() );
	}

	StdString file = fileName->GetString();
	file.MakeSafeFileName();
	CHashString safeFileName( file );

	// Map file unique IDs to corresponding state machines and vice versa
	// TODO: There seems to be a problem calling GetUniqueID() from the hash string returned from CQHStateMachine::GetFileName
	m_StateMachineToFileName[stateMachine->GetName()->GetUniqueID()] = safeFileName.GetUniqueID();
	m_FilenameToStateMachine[safeFileName.GetUniqueID()] = stateMachine;
}

CQHStateMachine *CQHStateMachineManager::GetStateMachineByFile( IHashString *fileName )
{
	CQHStateMachine *areturn = NULL;

	StdString file = fileName->GetString();
	file.MakeSafeFileName();
	CHashString srcFileName(file);

	static CHashString cqhsmTypeName(_T("CQHStateMachine"));
	IDTOOBJECTMAP::iterator fnameToSM = m_FilenameToStateMachine.find(srcFileName.GetUniqueID());
	if (fnameToSM != m_FilenameToStateMachine.end())
	{
		areturn = (CQHStateMachine*)(fnameToSM->second);
	}
	return areturn;
}

IBaseTextureObject * CTextureManager::GetTexture(IHashString *name )
{
	if( name != NULL )
	{
		StdString szSafeName = name->GetString();
		szSafeName.MakeSafeFileName();
		CHashString hsSafeName(szSafeName);
		//do we have it in the mapping already?
		TEXTURENAMEMAP::iterator cur = m_TextureNameMap.find( hsSafeName.GetUniqueID() );
		if( cur != m_TextureNameMap.end() )
		{
			//found one already loaded
			return (cur->second);
		}
	}
	return NULL;
}

/// message handler to check if a file exists
/// \param size - size of a CHECKFILEEXISTS
/// \param param - pointer to a CHECKFILEEXISTS struct
/// \return MSG_XXX return value
DWORD CZLibStreamFactory::OnCheckFileExists(DWORD size, void *param)
{
	VERIFY_MESSAGE_SIZE(size, sizeof(CHECKFILEEXISTS));
	CHECKFILEEXISTS &cfe = *(CHECKFILEEXISTS*)param;

	StdString sPath = cfe.pFilePath;
	sPath.MakeSafeFileName();
	sPath.ConformSlashesForward();

	if( CZipFileStream::CheckFileExist( sPath.c_str() ) )
	{
		cfe.bExists = true;
		return MSG_HANDLED_STOP;
	}
	
	cfe.bExists = false;
	return MSG_HANDLED_PROCEED;
}

bool CQHStateMachineManager::AddStateMachine( IHashString *afileName )
{
	bool areturn = false;
	if( afileName != NULL && 
		afileName->GetString() != NULL &&
		!afileName->IsEmpty() )
	{
		StdString file = afileName->GetString();
		file.MakeSafeFileName();
		LOADFILEEXTPARAMS lfep;
		lfep.fileName = (TCHAR*)file.c_str();
		lfep.bInternalLoad = true;

		static DWORD msgHash_LoadFileByExtension = CHashString(_T("LoadFileByExtension")).GetUniqueID();
		DWORD retVal = m_ToolBox->SendMessage(msgHash_LoadFileByExtension, sizeof(LOADFILEEXTPARAMS), &lfep);
	}

	return areturn;
}

/// \brief Adds a texture to the manager and returns a pointer to the object. If object already
/// exists, increments its internal reference count and returns the object. Takes
/// a structure of type TEXTUREOBJECTPARAMS
DWORD CTextureManager::OnAddTexture(DWORD size, void *params)
{
	//maybe change this to a loader? But texture objects should not exist in the hierarchy.
	//get the param structure
	TEXTUREOBJECTPARAMS *texObjParams;
	IBaseTextureObject * currentTexture = NULL;
	TEXTURENAMEMAP::iterator cur;

	texObjParams = (TEXTUREOBJECTPARAMS *)params;
	VERIFY_MESSAGE_SIZE(sizeof(TEXTUREOBJECTPARAMS), size);
	//look for it
	if( texObjParams->Name != NULL )
	{
		// convert to safe file name
		StdString szFileName = texObjParams->Name->GetString();
		szFileName.MakeSafeFileName();
		CHashString hashFile(szFileName);
		//do we have it in the mapping already?
		TEXTURENAMEMAP::iterator itr = m_TextureNameMap.find( hashFile.GetUniqueID() );
		if (itr != m_TextureNameMap.end())
			currentTexture = itr->second;

		if( currentTexture != NULL )
		{
			currentTexture->IncrementRefCount();
		}
		else
		{
			if (texObjParams->bLoad)
			{
				if (m_currentTexMemArea == TEX_MEM_VIDEO)
				{
					//new texture
					//check extension
					if( _tcsstr( hashFile.GetString(), ".hdr" )!= NULL ) 
					{
						static CHashString texName(_T("CDX9TextureObject"));
						currentTexture = (ITextureObject*)CreateTextureObject( &hashFile,  &texName);
						assert( currentTexture );
						currentTexture->SetTextureName( &hashFile );
						currentTexture->LoadFromFile(hashFile.GetString() );
					}else if( _tcsstr( hashFile.GetString(), ".ant" )!= NULL ) 
					{
						static CHashString aniTexObj(_T("CAnimatedTextureObject") );
						currentTexture = CreateTextureObject( &hashFile, &aniTexObj);
						currentTexture->LoadFromFile(hashFile.GetString() );
					}else if( _tcsstr( hashFile.GetString(), _T(".dds") ) != NULL )
					{
						//we can automatically load cubemap textures if it is a cubemap texture
						currentTexture = LoadCubeDDSTexture( &hashFile );
					}
				}

				// use the internal loader as it deals with a lot of issues
				// (ie. linear vs. tiled texture alignments/restrictions) for us.
				// and gets around the bug in DevIL on small mip levels of textures
				if( !currentTexture )
				{
					static CHashString DX9TexObj(_T("CDX9TextureObject"));
					currentTexture = CreateTextureObject( &hashFile, &DX9TexObj);
					currentTexture->SetTextureName( &hashFile );
					if (!currentTexture->LoadFromFile( hashFile.GetString() ))
					{
						DeleteTextureObject( currentTexture );
						currentTexture = NULL;
					}
				}

				//try loading file by extension
				if( !currentTexture )
				{
					currentTexture = LoadTextureByExtension( &hashFile );
				}

				if( !currentTexture )
				{
					// log message about creating or allocating memory
					m_ToolBox->Log( LOGERROR, _T("Could not create texture %s\n"),
						hashFile.GetString() );
					return MSG_ERROR;
				}
			}
			else
			{
				currentTexture = texObjParams->TextureObjectInterface;
				currentTexture->IncrementRefCount();
			}
			//add to internal list
			m_TextureNameMap[hashFile.GetUniqueID()] = currentTexture;
		}		
		//set the return value
		texObjParams->TextureObjectInterface = currentTexture;
		
	}
	else //No name/filename specified, return nothing
	{
		texObjParams->TextureObjectInterface = NULL;
//.........这里部分代码省略.........