SWORD25: Comply to the code conventions for several classes

svn-id: r53310

10 files changed, 77 insertions, 77 deletions

diff --git a/engines/sword25/kernel/inputpersistenceblock.cpp b/engines/sword25/kernel/inputpersistenceblock.cpp
index cbf2e5b1f9..b51b1037a7 100644
--- a/engines/sword25/kernel/inputpersistenceblock.cpp
+++ b/engines/sword25/kernel/inputpersistenceblock.cpp
@@ -62,15 +62,15 @@ InputPersistenceBlock::~InputPersistenceBlock() {
 // Reading
 // -----------------------------------------------------------------------------
 
-void InputPersistenceBlock::Read(int16 &Value) {
+void InputPersistenceBlock::read(int16 &Value) {
 	signed int v;
-	Read(v);
+	read(v);
 	Value = static_cast<int16>(v);
 }
 
 // -----------------------------------------------------------------------------
 
-void InputPersistenceBlock::Read(signed int &Value) {
+void InputPersistenceBlock::read(signed int &Value) {
 	if (CheckMarker(SINT_MARKER)) {
 		RawRead(&Value, sizeof(signed int));
 		Value = ConvertEndianessFromStorageToSystem(Value);
@@ -81,7 +81,7 @@ void InputPersistenceBlock::Read(signed int &Value) {
 
 // -----------------------------------------------------------------------------
 
-void InputPersistenceBlock::Read(uint &Value) {
+void InputPersistenceBlock::read(uint &Value) {
 	if (CheckMarker(UINT_MARKER)) {
 		RawRead(&Value, sizeof(uint));
 		Value = ConvertEndianessFromStorageToSystem(Value);
@@ -92,7 +92,7 @@ void InputPersistenceBlock::Read(uint &Value) {
 
 // -----------------------------------------------------------------------------
 
-void InputPersistenceBlock::Read(float &Value) {
+void InputPersistenceBlock::read(float &Value) {
 	if (CheckMarker(FLOAT_MARKER)) {
 		RawRead(&Value, sizeof(float));
 		Value = ConvertEndianessFromStorageToSystem(Value);
@@ -103,7 +103,7 @@ void InputPersistenceBlock::Read(float &Value) {
 
 // -----------------------------------------------------------------------------
 
-void InputPersistenceBlock::Read(bool &Value) {
+void InputPersistenceBlock::read(bool &Value) {
 	if (CheckMarker(BOOL_MARKER)) {
 		uint UIntBool;
 		RawRead(&UIntBool, sizeof(float));
@@ -116,12 +116,12 @@ void InputPersistenceBlock::Read(bool &Value) {
 
 // -----------------------------------------------------------------------------
 
-void InputPersistenceBlock::Read(Common::String &Value) {
+void InputPersistenceBlock::read(Common::String &Value) {
 	Value = "";
 
 	if (CheckMarker(STRING_MARKER)) {
 		uint Size;
-		Read(Size);
+		read(Size);
 
 		if (CheckBlockSize(Size)) {
 			Value = Common::String(reinterpret_cast<const char *>(&*m_Iter), Size);
@@ -132,10 +132,10 @@ void InputPersistenceBlock::Read(Common::String &Value) {
 
 // -----------------------------------------------------------------------------
 
-void InputPersistenceBlock::Read(Common::Array<byte> &Value) {
+void InputPersistenceBlock::read(Common::Array<byte> &Value) {
 	if (CheckMarker(BLOCK_MARKER)) {
 		uint Size;
-		Read(Size);
+		read(Size);
 
 		if (CheckBlockSize(Size)) {
 			Value = Common::Array<byte>(m_Iter, Size);
@@ -168,7 +168,7 @@ bool InputPersistenceBlock::CheckBlockSize(int Size) {
 // -----------------------------------------------------------------------------
 
 bool InputPersistenceBlock::CheckMarker(byte Marker) {
-	if (!IsGood() || !CheckBlockSize(1)) return false;
+	if (!isGood() || !CheckBlockSize(1)) return false;
 
 	if (*m_Iter++ == Marker) {
 		return true;
diff --git a/engines/sword25/kernel/inputpersistenceblock.h b/engines/sword25/kernel/inputpersistenceblock.h
index 3e39a69918..a6978e5899 100644
--- a/engines/sword25/kernel/inputpersistenceblock.h
+++ b/engines/sword25/kernel/inputpersistenceblock.h
@@ -60,15 +60,15 @@ public:
 	InputPersistenceBlock(const void *Data, uint DataLength);
 	virtual ~InputPersistenceBlock();
 
-	void Read(int16 &Value);
-	void Read(signed int &Value);
-	void Read(uint &Value);
-	void Read(float &Value);
-	void Read(bool &Value);
-	void Read(Common::String &Value);
-	void Read(Common::Array<byte> &Value);
-
-	bool IsGood() const {
+	void read(int16 &Value);
+	void read(signed int &Value);
+	void read(uint &Value);
+	void read(float &Value);
+	void read(bool &Value);
+	void read(Common::String &Value);
+	void read(Common::Array<byte> &Value);
+
+	bool isGood() const {
 		return m_ErrorState == NONE;
 	}
 	ErrorState GetErrorState() const {
diff --git a/engines/sword25/kernel/objectregistry.h b/engines/sword25/kernel/objectregistry.h
index 3e80ec9321..0ae3915edb 100644
--- a/engines/sword25/kernel/objectregistry.h
+++ b/engines/sword25/kernel/objectregistry.h
@@ -129,7 +129,7 @@ public:
 
 	// -----------------------------------------------------------------------------
 
-	T *ResolveHandle(uint Handle) {
+	T *resolveHandle(uint Handle) {
 		// Zum Handle gehöriges Objekt in der Hash-Map finden.
 		T *ObjectPtr = FindPtrByHandle(Handle);
 
diff --git a/engines/sword25/kernel/outputpersistenceblock.cpp b/engines/sword25/kernel/outputpersistenceblock.cpp
index 0394aa1808..438fa7b222 100644
--- a/engines/sword25/kernel/outputpersistenceblock.cpp
+++ b/engines/sword25/kernel/outputpersistenceblock.cpp
@@ -62,7 +62,7 @@ OutputPersistenceBlock::OutputPersistenceBlock() {
 // Writing
 // -----------------------------------------------------------------------------
 
-void OutputPersistenceBlock::Write(signed int Value) {
+void OutputPersistenceBlock::write(signed int Value) {
 	WriteMarker(SINT_MARKER);
 	Value = ConvertEndianessFromSystemToStorage(Value);
 	RawWrite(&Value, sizeof(Value));
@@ -70,7 +70,7 @@ void OutputPersistenceBlock::Write(signed int Value) {
 
 // -----------------------------------------------------------------------------
 
-void OutputPersistenceBlock::Write(uint Value) {
+void OutputPersistenceBlock::write(uint Value) {
 	WriteMarker(UINT_MARKER);
 	Value = ConvertEndianessFromSystemToStorage(Value);
 	RawWrite(&Value, sizeof(Value));
@@ -78,7 +78,7 @@ void OutputPersistenceBlock::Write(uint Value) {
 
 // -----------------------------------------------------------------------------
 
-void OutputPersistenceBlock::Write(float Value) {
+void OutputPersistenceBlock::write(float Value) {
 	WriteMarker(FLOAT_MARKER);
 	Value = ConvertEndianessFromSystemToStorage(Value);
 	RawWrite(&Value, sizeof(Value));
@@ -86,7 +86,7 @@ void OutputPersistenceBlock::Write(float Value) {
 
 // -----------------------------------------------------------------------------
 
-void OutputPersistenceBlock::Write(bool Value) {
+void OutputPersistenceBlock::write(bool Value) {
 	WriteMarker(BOOL_MARKER);
 
 	uint UIntBool = Value ? 1 : 0;
@@ -96,19 +96,19 @@ void OutputPersistenceBlock::Write(bool Value) {
 
 // -----------------------------------------------------------------------------
 
-void OutputPersistenceBlock::Write(const Common::String &String) {
+void OutputPersistenceBlock::write(const Common::String &String) {
 	WriteMarker(STRING_MARKER);
 
-	Write(String.size());
+	write(String.size());
 	RawWrite(String.c_str(), String.size());
 }
 
 // -----------------------------------------------------------------------------
 
-void OutputPersistenceBlock::Write(const void *BufferPtr, size_t Size) {
+void OutputPersistenceBlock::write(const void *BufferPtr, size_t Size) {
 	WriteMarker(BLOCK_MARKER);
 
-	Write(Size);
+	write(Size);
 	RawWrite(BufferPtr, Size);
 }
 
diff --git a/engines/sword25/kernel/outputpersistenceblock.h b/engines/sword25/kernel/outputpersistenceblock.h
index fab0552d31..154dbc9763 100644
--- a/engines/sword25/kernel/outputpersistenceblock.h
+++ b/engines/sword25/kernel/outputpersistenceblock.h
@@ -52,12 +52,12 @@ class OutputPersistenceBlock : public PersistenceBlock {
 public:
 	OutputPersistenceBlock();
 
-	void Write(signed int Value);
-	void Write(uint Value);
-	void Write(float Value);
-	void Write(bool Value);
-	void Write(const Common::String &String);
-	void Write(const void *BufferPtr, size_t Size);
+	void write(signed int Value);
+	void write(uint Value);
+	void write(float Value);
+	void write(bool Value);
+	void write(const Common::String &String);
+	void write(const void *BufferPtr, size_t Size);
 
 	const void *GetData() const {
 		return &m_Data[0];
diff --git a/engines/sword25/kernel/persistable.h b/engines/sword25/kernel/persistable.h
index 020bd2477c..fc314688d5 100644
--- a/engines/sword25/kernel/persistable.h
+++ b/engines/sword25/kernel/persistable.h
@@ -44,8 +44,8 @@ class Persistable {
 public:
 	virtual ~Persistable() {};
 
-	virtual bool Persist(OutputPersistenceBlock &Writer) = 0;
-	virtual bool Unpersist(InputPersistenceBlock &Reader) = 0;
+	virtual bool persist(OutputPersistenceBlock &writer) = 0;
+	virtual bool unpersist(InputPersistenceBlock &reader) = 0;
 };
 
 } // End of namespace Sword25
diff --git a/engines/sword25/kernel/persistenceservice.cpp b/engines/sword25/kernel/persistenceservice.cpp
index 696f85459e..46e9bbea3b 100644
--- a/engines/sword25/kernel/persistenceservice.cpp
+++ b/engines/sword25/kernel/persistenceservice.cpp
@@ -318,11 +318,11 @@ bool PersistenceService::SaveGame(uint SlotID, const Common::String &ScreenshotF
 	// Alle notwendigen Module persistieren.
 	OutputPersistenceBlock Writer;
 	bool Success = true;
-	Success &= Kernel::GetInstance()->GetScript()->Persist(Writer);
-	Success &= RegionRegistry::GetInstance().Persist(Writer);
-	Success &= Kernel::GetInstance()->GetGfx()->Persist(Writer);
-	Success &= Kernel::GetInstance()->GetSfx()->Persist(Writer);
-	Success &= Kernel::GetInstance()->GetInput()->Persist(Writer);
+	Success &= Kernel::GetInstance()->GetScript()->persist(Writer);
+	Success &= RegionRegistry::GetInstance().persist(Writer);
+	Success &= Kernel::GetInstance()->GetGfx()->persist(Writer);
+	Success &= Kernel::GetInstance()->GetSfx()->persist(Writer);
+	Success &= Kernel::GetInstance()->GetInput()->persist(Writer);
 	if (!Success) {
 		error("Unable to persist modules for savegame file \"%s\".", Filename.c_str());
 	}
@@ -433,12 +433,12 @@ bool PersistenceService::LoadGame(uint SlotID) {
 
 	// Einzelne Engine-Module depersistieren.
 	bool Success = true;
-	Success &= Kernel::GetInstance()->GetScript()->Unpersist(Reader);
+	Success &= Kernel::GetInstance()->GetScript()->unpersist(Reader);
 	// Muss unbedingt nach Script passieren. Da sonst die bereits wiederhergestellten Regions per Garbage-Collection gekillt werden.
-	Success &= RegionRegistry::GetInstance().Unpersist(Reader);
-	Success &= Kernel::GetInstance()->GetGfx()->Unpersist(Reader);
-	Success &= Kernel::GetInstance()->GetSfx()->Unpersist(Reader);
-	Success &= Kernel::GetInstance()->GetInput()->Unpersist(Reader);
+	Success &= RegionRegistry::GetInstance().unpersist(Reader);
+	Success &= Kernel::GetInstance()->GetGfx()->unpersist(Reader);
+	Success &= Kernel::GetInstance()->GetSfx()->unpersist(Reader);
+	Success &= Kernel::GetInstance()->GetInput()->unpersist(Reader);
 
 	delete[] CompressedDataBuffer;
 	delete[] UncompressedDataBuffer;
diff --git a/engines/sword25/kernel/resmanager.cpp b/engines/sword25/kernel/resmanager.cpp
index 59f1034704..a671f9568d 100644
--- a/engines/sword25/kernel/resmanager.cpp
+++ b/engines/sword25/kernel/resmanager.cpp
@@ -50,11 +50,11 @@ ResourceManager::~ResourceManager() {
 	// 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());
+		BS_LOG_WARNINGLN("Resource \"%s\" was not released.", (*Iter)->getFileName().c_str());
 
 		// Set the lock count to zero
 		while ((*Iter)->GetLockCount() > 0) {
-			(*Iter)->Release();
+			(*Iter)->release();
 		};
 
 		// Delete the resource
@@ -208,11 +208,11 @@ bool ResourceManager::PrecacheResource(const Common::String &FileName, bool Forc
  */
 void ResourceManager::MoveToFront(Resource *pResource) {
 	// Erase the resource from it's current position
-	m_Resources.erase(pResource->_Iterator);
+	m_Resources.erase(pResource->_iterator);
 	// Re-add the resource at the front of the list
 	m_Resources.push_front(pResource);
 	// Reset the resource iterator to the repositioned item
-	pResource->_Iterator = m_Resources.begin();
+	pResource->_iterator = m_Resources.begin();
 }
 
 /**
@@ -237,7 +237,7 @@ Resource *ResourceManager::LoadResource(const Common::String &FileName) {
 
 			// Add the resource to the front of the list
 			m_Resources.push_front(pResource);
-			pResource->_Iterator = m_Resources.begin();
+			pResource->_iterator = m_Resources.begin();
 
 			// Also store the resource in the hash table for quick lookup
 			m_ResourceHashTable[pResource->GetFileNameHash() % HASH_TABLE_BUCKETS].push_front(pResource);
@@ -280,7 +280,7 @@ Common::List<Resource *>::iterator ResourceManager::DeleteResource(Resource *pRe
 	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 = m_Resources.erase(pResource->_iterator);
 
 	// Delete the resource
 	delete(pDummy);
@@ -302,7 +302,7 @@ Resource *ResourceManager::GetResource(const Common::String &UniqueFileName) con
 		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)
+			if ((*Iter)->getFileName() == UniqueFileName)
 				return *Iter;
 		}
 	}
@@ -317,7 +317,7 @@ Resource *ResourceManager::GetResource(const Common::String &UniqueFileName) con
 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());
+			BS_LOGLN("%s", (*Iter)->getFileName().c_str());
 		}
 	}
 }
diff --git a/engines/sword25/kernel/resource.cpp b/engines/sword25/kernel/resource.cpp
index 9456270034..813ee54cd3 100644
--- a/engines/sword25/kernel/resource.cpp
+++ b/engines/sword25/kernel/resource.cpp
@@ -41,20 +41,20 @@ namespace Sword25 {
 
 #define BS_LOG_PREFIX "RESOURCE"
 
-Resource::Resource(const Common::String &FileName, RESOURCE_TYPES Type) :
-	_Type(Type),
-	_RefCount(0) {
+Resource::Resource(const Common::String &fileName, RESOURCE_TYPES type) :
+	_type(type),
+	_refCount(0) {
 	BS_ASSERT(Kernel::GetInstance()->GetService("package"));
 
-	_FileName = static_cast<PackageManager *>(Kernel::GetInstance()->GetService("package"))->GetAbsolutePath(FileName);
-	_FileNameHash = BS_String::GetHash(FileName);
+	_fileName = static_cast<PackageManager *>(Kernel::GetInstance()->GetService("package"))->GetAbsolutePath(fileName);
+	_fileNameHash = BS_String::GetHash(fileName);
 }
 
-void Resource::Release() {
-	if (_RefCount) {
-		--_RefCount;
+void Resource::release() {
+	if (_refCount) {
+		--_refCount;
 	} else
-		BS_LOG_WARNINGLN("Released unlocked resource \"%s\".", _FileName.c_str());
+		BS_LOG_WARNINGLN("Released unlocked resource \"%s\".", _fileName.c_str());
 }
 
 } // End of namespace Sword25
diff --git a/engines/sword25/kernel/resource.h b/engines/sword25/kernel/resource.h
index a78129666e..2a4d197138 100644
--- a/engines/sword25/kernel/resource.h
+++ b/engines/sword25/kernel/resource.h
@@ -56,14 +56,14 @@ public:
 		TYPE_FONT
 	};
 
-	Resource(const Common::String &UniqueFileName, RESOURCE_TYPES Type);
+	Resource(const Common::String &uniqueFileName, RESOURCE_TYPES type);
 
 	/**
 	 * Prevents the resource from being released.
 	 * @remarks             This method allows a resource to be locked multiple times.
 	 **/
 	void AddReference() {
-		++_RefCount;
+		++_refCount;
 	}
 
 	/**
@@ -71,46 +71,46 @@ public:
 	 * @remarks             The resource can still be released more times than it was 'locked', although it is
 	 * not recommended.
 	 **/
-	void Release();
+	void release();
 
 	/**
 	 * Returns the current lock count for the resource
 	 * @return              The current lock count
 	 **/
 	int GetLockCount() const {
-		return _RefCount;
+		return _refCount;
 	}
 
 	/**
 	 * Returns the absolute path of the given resource
 	 */
-	const Common::String &GetFileName() const {
-		return _FileName;
+	const Common::String &getFileName() const {
+		return _fileName;
 	}
 
 	/**
 	 * Returns the hash of the filename of a resource
 	*/
 	uint GetFileNameHash() const {
-		return _FileNameHash;
+		return _fileNameHash;
 	}
 
 	/**
 	 * Returns a resource's type
 	 */
 	uint GetType() const {
-		return _Type;
+		return _type;
 	}
 
 protected:
 	virtual ~Resource() {};
 
 private:
-	Common::String                      _FileName;          ///< The absolute filename
-	uint                        _FileNameHash;      ///< The hash value of the filename
-	uint                        _RefCount;          ///< The number of locks
-	uint                        _Type;              ///< The type of the resource
-	Common::List<Resource *>::iterator _Iterator;        ///< Points to the resource position in the LRU list
+	Common::String                      _fileName;          ///< The absolute filename
+	uint                        _fileNameHash;      ///< The hash value of the filename
+	uint                        _refCount;          ///< The number of locks
+	uint                        _type;              ///< The type of the resource
+	Common::List<Resource *>::iterator _iterator;        ///< Points to the resource position in the LRU list
 };
 
 } // End of namespace Sword25