SWORD25: Enforced code formatting rules in rest of the engine

svn-id: r53626

1 files changed, 87 insertions, 85 deletions

diff --git a/engines/sword25/kernel/resmanager.cpp b/engines/sword25/kernel/resmanager.cpp
index 0374acf307..c2ecb04a6f 100644
--- a/engines/sword25/kernel/resmanager.cpp
+++ b/engines/sword25/kernel/resmanager.cpp
@@ -45,20 +45,20 @@ namespace Sword25 {
 
 ResourceManager::~ResourceManager() {
 	// Clear all unlocked resources
-	EmptyCache();
+	emptyCache();
 
 	// All remaining resources are not released, so print warnings and release
-	Common::List<Resource *>::iterator Iter = m_Resources.begin();
-	for (; Iter != m_Resources.end(); ++Iter) {
-		BS_LOG_WARNINGLN("Resource \"%s\" was not released.", (*Iter)->getFileName().c_str());
+	Common::List<Resource *>::iterator iter = _resources.begin();
+	for (; iter != _resources.end(); ++iter) {
+		BS_LOG_WARNINGLN("Resource \"%s\" was not released.", (*iter)->getFileName().c_str());
 
 		// Set the lock count to zero
-		while ((*Iter)->GetLockCount() > 0) {
-			(*Iter)->release();
+		while ((*iter)->getLockCount() > 0) {
+			(*iter)->release();
 		};
 
 		// Delete the resource
-		delete(*Iter);
+		delete(*iter);
 	}
 }
 
@@ -67,19 +67,19 @@ ResourceManager::~ResourceManager() {
  * Note: This method is not optimised for speed and should be used only for debugging purposes
  * @param Ord       Ordinal number of the resource. Must be between 0 and GetResourceCount() - 1.
  */
-Resource *ResourceManager::GetResourceByOrdinal(int Ord) const {
+Resource *ResourceManager::getResourceByOrdinal(int ord) const {
 	// Überprüfen ob der Index Ord innerhald der Listengrenzen liegt.
-	if (Ord < 0 || Ord >= GetResourceCount()) {
-		BS_LOG_ERRORLN("Resource ordinal (%d) out of bounds (0 - %d).", Ord, GetResourceCount() - 1);
+	if (ord < 0 || ord >= getResourceCount()) {
+		BS_LOG_ERRORLN("Resource ordinal (%d) out of bounds (0 - %d).", ord, getResourceCount() - 1);
 		return NULL;
 	}
 
 	// Liste durchlaufen und die Resource mit dem gewünschten Index zurückgeben.
-	int CurOrd = 0;
-	Common::List<Resource *>::const_iterator Iter = m_Resources.begin();
-	for (; Iter != m_Resources.end(); ++Iter, ++CurOrd) {
-		if (CurOrd == Ord)
-			return (*Iter);
+	int curOrd = 0;
+	Common::List<Resource *>::const_iterator iter = _resources.begin();
+	for (; iter != _resources.end(); ++iter, ++curOrd) {
+		if (curOrd == ord)
+			return (*iter);
 	}
 
 	// Die Ausführung sollte nie an diesem Punkt ankommen.
@@ -92,13 +92,13 @@ Resource *ResourceManager::GetResourceByOrdinal(int Ord) const {
  * BS_ResourceService, and thus helps all resource services in the ResourceManager list
  * @param pService      Which service
  */
-bool ResourceManager::RegisterResourceService(ResourceService *pService) {
+bool ResourceManager::registerResourceService(ResourceService *pService) {
 	if (!pService) {
 		BS_LOG_ERRORLN("Can't register NULL resource service.");
 		return false;
 	}
 
-	m_ResourceServices.push_back(pService);
+	_resourceServices.push_back(pService);
 
 	return true;
 }
@@ -106,34 +106,36 @@ bool ResourceManager::RegisterResourceService(ResourceService *pService) {
 /**
  * Deletes resources as necessary until the specified memory limit is not being exceeded.
  */
-void ResourceManager::DeleteResourcesIfNecessary() {
+void ResourceManager::deleteResourcesIfNecessary() {
 	// If enough memory is available, or no resources are loaded, then the function can immediately end
-	if (m_KernelPtr->GetUsedMemory() < m_MaxMemoryUsage || m_Resources.empty()) return;
+	if (_kernelPtr->getUsedMemory() < _maxMemoryUsage || _resources.empty())
+		return;
 
 	// Keep deleting resources until the memory usage of the process falls below the set maximum limit.
 	// The list is processed backwards in order to first release those resources who have been
 	// not been accessed for the longest
-	Common::List<Resource *>::iterator Iter = m_Resources.end();
+	Common::List<Resource *>::iterator iter = _resources.end();
 	do {
-		--Iter;
+		--iter;
 
 		// The resource may be released only if it isn't locked
-		if ((*Iter)->GetLockCount() == 0) Iter = DeleteResource(*Iter);
-	} while (Iter != m_Resources.begin() && m_KernelPtr->GetUsedMemory() > m_MaxMemoryUsage);
+		if ((*iter)->getLockCount() == 0)
+			iter = deleteResource(*iter);
+	} while (iter != _resources.begin() && _kernelPtr->getUsedMemory() > _maxMemoryUsage);
 }
 
 /**
  * Releases all resources that are not locked.
  **/
-void ResourceManager::EmptyCache() {
+void ResourceManager::emptyCache() {
 	// Scan through the resource list
-	Common::List<Resource *>::iterator Iter = m_Resources.begin();
-	while (Iter != m_Resources.end()) {
-		if ((*Iter)->GetLockCount() == 0) {
+	Common::List<Resource *>::iterator iter = _resources.begin();
+	while (iter != _resources.end()) {
+		if ((*iter)->getLockCount() == 0) {
 			// Delete the resource
-			Iter = DeleteResource(*Iter);
+			iter = deleteResource(*iter);
 		} else
-			++Iter;
+			++iter;
 	}
 }
 
@@ -141,29 +143,30 @@ void ResourceManager::EmptyCache() {
  * Returns a requested resource. If any error occurs, returns NULL
  * @param FileName      Filename of resource
  */
-Resource *ResourceManager::RequestResource(const Common::String &FileName) {
+Resource *ResourceManager::requestResource(const Common::String &fileName) {
 	// Get the absolute path to the file
-	Common::String UniqueFileName = GetUniqueFileName(FileName);
-	if (UniqueFileName == "")
+	Common::String uniqueFileName = getUniqueFileName(fileName);
+	if (uniqueFileName == "")
 		return NULL;
 
 	// Determine whether the resource is already loaded
 	// If the resource is found, it will be placed at the head of the resource list and returned
 	{
-		Resource *pResource = GetResource(UniqueFileName);
+		Resource *pResource = getResource(uniqueFileName);
 		if (pResource) {
-			MoveToFront(pResource);
-			(pResource)->AddReference();
+			moveToFront(pResource);
+			(pResource)->addReference();
 			return pResource;
 		}
 	}
 
 	// The resource was not found, therefore, must not be loaded yet
-	if (m_LogCacheMiss) BS_LOG_WARNINGLN("\"%s\" was not precached.", UniqueFileName.c_str());
+	if (_logCacheMiss)
+		BS_LOG_WARNINGLN("\"%s\" was not precached.", uniqueFileName.c_str());
 
 	Resource *pResource;
-	if ((pResource = loadResource(UniqueFileName))) {
-		pResource->AddReference();
+	if ((pResource = loadResource(uniqueFileName))) {
+		pResource->addReference();
 		return pResource;
 	}
 
@@ -176,26 +179,26 @@ Resource *ResourceManager::RequestResource(const Common::String &FileName) {
  * @param ForceReload   Indicates whether the file should be reloaded if it's already in the cache.
  * This is useful for files that may have changed in the interim
  */
-bool ResourceManager::PrecacheResource(const Common::String &FileName, bool ForceReload) {
+bool ResourceManager::precacheResource(const Common::String &fileName, bool forceReload) {
 	// Get the absolute path to the file
-	Common::String UniqueFileName = GetUniqueFileName(FileName);
-	if (UniqueFileName == "")
+	Common::String uniqueFileName = getUniqueFileName(fileName);
+	if (uniqueFileName == "")
 		return false;
 
-	Resource *ResourcePtr = GetResource(UniqueFileName);
+	Resource *resourcePtr = getResource(uniqueFileName);
 
-	if (ForceReload && ResourcePtr) {
-		if (ResourcePtr->GetLockCount()) {
-			BS_LOG_ERRORLN("Could not force precaching of \"%s\". The resource is locked.", FileName.c_str());
+	if (forceReload && resourcePtr) {
+		if (resourcePtr->getLockCount()) {
+			BS_LOG_ERRORLN("Could not force precaching of \"%s\". The resource is locked.", fileName.c_str());
 			return false;
 		} else {
-			DeleteResource(ResourcePtr);
-			ResourcePtr = 0;
+			deleteResource(resourcePtr);
+			resourcePtr = 0;
 		}
 	}
 
-	if (!ResourcePtr && loadResource(UniqueFileName) == NULL) {
-		BS_LOG_ERRORLN("Could not precache \"%s\",", FileName.c_str());
+	if (!resourcePtr && loadResource(uniqueFileName) == NULL) {
+		BS_LOG_ERRORLN("Could not precache \"%s\",", fileName.c_str());
 		return false;
 	}
 
@@ -206,13 +209,13 @@ bool ResourceManager::PrecacheResource(const Common::String &FileName, bool Forc
  * Moves a resource to the top of the resource list
  * @param pResource     The resource
  */
-void ResourceManager::MoveToFront(Resource *pResource) {
+void ResourceManager::moveToFront(Resource *pResource) {
 	// Erase the resource from it's current position
-	m_Resources.erase(pResource->_iterator);
+	_resources.erase(pResource->_iterator);
 	// Re-add the resource at the front of the list
-	m_Resources.push_front(pResource);
+	_resources.push_front(pResource);
 	// Reset the resource iterator to the repositioned item
-	pResource->_iterator = m_Resources.begin();
+	pResource->_iterator = _resources.begin();
 }
 
 /**
@@ -223,24 +226,24 @@ void ResourceManager::MoveToFront(Resource *pResource) {
  */
 Resource *ResourceManager::loadResource(const Common::String &fileName) {
 	// ResourceService finden, der die Resource laden kann.
-	for (uint i = 0; i < m_ResourceServices.size(); ++i) {
-		if (m_ResourceServices[i]->canLoadResource(fileName)) {
+	for (uint i = 0; i < _resourceServices.size(); ++i) {
+		if (_resourceServices[i]->canLoadResource(fileName)) {
 			// If more memory is desired, memory must be released
-			DeleteResourcesIfNecessary();
+			deleteResourcesIfNecessary();
 
 			// Load the resource
 			Resource *pResource;
-			if (!(pResource = m_ResourceServices[i]->loadResource(fileName))) {
+			if (!(pResource = _resourceServices[i]->loadResource(fileName))) {
 				BS_LOG_ERRORLN("Responsible service could not load resource \"%s\".", fileName.c_str());
 				return NULL;
 			}
 
 			// Add the resource to the front of the list
-			m_Resources.push_front(pResource);
-			pResource->_iterator = m_Resources.begin();
+			_resources.push_front(pResource);
+			pResource->_iterator = _resources.begin();
 
 			// Also store the resource in the hash table for quick lookup
-			m_ResourceHashTable[pResource->GetFileNameHash() % HASH_TABLE_BUCKETS].push_front(pResource);
+			_resourceHashTable[pResource->getFileNameHash() % HASH_TABLE_BUCKETS].push_front(pResource);
 
 			return pResource;
 		}
@@ -254,56 +257,55 @@ Resource *ResourceManager::loadResource(const Common::String &fileName) {
  * Returns the full path of a given resource filename.
  * It will return an empty string if a path could not be created.
 */
-Common::String ResourceManager::GetUniqueFileName(const Common::String &FileName) const {
+Common::String ResourceManager::getUniqueFileName(const Common::String &fileName) const {
 	// Get a pointer to the package manager
-	PackageManager *pPackage = (PackageManager *)m_KernelPtr->GetPackage();
+	PackageManager *pPackage = (PackageManager *)_kernelPtr->getPackage();
 	if (!pPackage) {
 		BS_LOG_ERRORLN("Could not get package manager.");
 		return Common::String("");
 	}
 
 	// Absoluten Pfad der Datei bekommen und somit die Eindeutigkeit des Dateinamens sicherstellen
-	Common::String UniqueFileName = pPackage->getAbsolutePath(FileName);
-	if (UniqueFileName == "")
-		BS_LOG_ERRORLN("Could not create absolute file name for \"%s\".", FileName.c_str());
+	Common::String uniquefileName = pPackage->getAbsolutePath(fileName);
+	if (uniquefileName == "")
+		BS_LOG_ERRORLN("Could not create absolute file name for \"%s\".", fileName.c_str());
 
-	return UniqueFileName;
+	return uniquefileName;
 }
 
 /**
  * Deletes a resource, removes it from the lists, and updates m_UsedMemory
  */
-Common::List<Resource *>::iterator ResourceManager::DeleteResource(Resource *pResource) {
+Common::List<Resource *>::iterator ResourceManager::deleteResource(Resource *pResource) {
 	// Remove the resource from the hash table
-	m_ResourceHashTable[pResource->GetFileNameHash() % HASH_TABLE_BUCKETS].remove(pResource);
+	_resourceHashTable[pResource->getFileNameHash() % HASH_TABLE_BUCKETS].remove(pResource);
 
 	Resource *pDummy = pResource;
 
 	// Delete the resource from the resource list
-	Common::List<Resource *>::iterator Result = m_Resources.erase(pResource->_iterator);
+	Common::List<Resource *>::iterator result = _resources.erase(pResource->_iterator);
 
 	// Delete the resource
 	delete(pDummy);
 
 	// Return the iterator
-	return Result;
+	return result;
 }
 
 /**
  * Returns a pointer to a loaded resource. If any error occurs, NULL will be returned.
- * @param UniqueFileName        The absolute path and filename
+ * @param UniquefileName        The absolute path and filename
  * Gibt einen Pointer auf die angeforderte Resource zurück, oder NULL, wenn die Resourcen nicht geladen ist.
  */
-Resource *ResourceManager::GetResource(const Common::String &UniqueFileName) const {
+Resource *ResourceManager::getResource(const Common::String &uniquefileName) const {
 	// Determine whether the resource is already loaded
-	const Common::List<Resource *>& HashBucket = m_ResourceHashTable[
-	            BS_String::GetHash(UniqueFileName) % HASH_TABLE_BUCKETS];
+	const Common::List<Resource *>& hashBucket = _resourceHashTable[BS_String::getHash(uniquefileName) % HASH_TABLE_BUCKETS];
 	{
-		Common::List<Resource *>::const_iterator Iter = HashBucket.begin();
-		for (; Iter != HashBucket.end(); ++Iter) {
+		Common::List<Resource *>::const_iterator iter = hashBucket.begin();
+		for (; iter != hashBucket.end(); ++iter) {
 			// Wenn die Resource gefunden wurde wird sie zurückgegeben.
-			if ((*Iter)->getFileName() == UniqueFileName)
-				return *Iter;
+			if ((*iter)->getFileName() == uniquefileName)
+				return *iter;
 		}
 	}
 
@@ -314,10 +316,10 @@ Resource *ResourceManager::GetResource(const Common::String &UniqueFileName) con
 /**
  * Writes the names of all currently locked resources to the log file
  */
-void ResourceManager::DumpLockedResources() {
-	for (Common::List<Resource *>::iterator Iter = m_Resources.begin(); Iter != m_Resources.end(); ++Iter) {
-		if ((*Iter)->GetLockCount() > 0) {
-			BS_LOGLN("%s", (*Iter)->getFileName().c_str());
+void ResourceManager::dumpLockedResources() {
+	for (Common::List<Resource *>::iterator iter = _resources.begin(); iter != _resources.end(); ++iter) {
+		if ((*iter)->getLockCount() > 0) {
+			BS_LOGLN("%s", (*iter)->getFileName().c_str());
 		}
 	}
 }
@@ -328,9 +330,9 @@ void ResourceManager::DumpLockedResources() {
  * as a guideline, and not as a fixed boundary. It is not guaranteed not to be exceeded;
  * the whole game engine may still use more memory than any amount specified.
  */
-void ResourceManager::SetMaxMemoryUsage(uint MaxMemoryUsage) {
-	m_MaxMemoryUsage = MaxMemoryUsage;
-	DeleteResourcesIfNecessary();
+void ResourceManager::setMaxMemoryUsage(uint maxMemoryUsage) {
+	_maxMemoryUsage = maxMemoryUsage;
+	deleteResourcesIfNecessary();
 }
 
 } // End of namespace Sword25