1 files changed, 58 insertions, 58 deletions

diff --git a/source/modules/asura-utils/io/file.cpp b/source/modules/asura-utils/io/file.cpp
index 9e89c85..2061fb1 100644
--- a/source/modules/asura-utils/io/file.cpp
+++ b/source/modules/asura-utils/io/file.cpp
@@ -10,25 +10,25 @@ namespace AsuraEngine
 	{
 
 		File::File(const std::string& filename)
-			: mFileName(filename)
-			, mFileHandle(nullptr)
-			, mMode(FILE_MODE_CLOSED)
-			, mBufferMode(BUFFER_MODE_NONE)
-			, mBufferSize(0)
+			: m_FileName(filename)
+			, m_FileHandle(nullptr)
+			, m_Mode(FILE_MODE_CLOSED)
+			, m_BufferMode(BUFFER_MODE_NONE)
+			, m_BufferSize(0)
 		{
 			size_t dot = filename.rfind('.');
 			if (dot != std::string::npos)
 			{
-				mExtension = filename.substr(dot + 1);
-				mName = filename.substr(0, dot);
+			 m_Extension = filename.substr(dot + 1);
+			 m_Name = filename.substr(0, dot);
 			}
 			else
-				mName = filename;
+			 m_Name = filename;
 		}
 
 		File::~File()
 		{
-			if (mMode != FILE_MODE_CLOSED)
+			if (m_Mode != FILE_MODE_CLOSED)
 				Close();
 		}
 
@@ -40,8 +40,8 @@ namespace AsuraEngine
 			if (mode == FILE_MODE_CLOSED)
 				return false;
 
-			if (mode == FILE_MODE_READ && !PHYSFS_exists(mFileName.c_str()))
-				throw Exception("Could NOT open file %s. Does not exist.", mFileName.c_str());
+			if (mode == FILE_MODE_READ && !PHYSFS_exists(m_FileName.c_str()))
+				throw Exception("Could NOT open file %s. Does not exist.", m_FileName.c_str());
 
 			if (mode == FILE_MODE_APPEND || mode == FILE_MODE_WRITE)
 			{
@@ -52,7 +52,7 @@ namespace AsuraEngine
 			}
 
 			// �Ѿ���֮ǰ�򿪹����Ͳ��ٴ����µ�handle��
-			if (mFileHandle != nullptr)
+			if (m_FileHandle != nullptr)
 				return true;
 
 			PHYSFS_getLastErrorCode();
@@ -62,13 +62,13 @@ namespace AsuraEngine
 			switch (mode)
 			{
 			case FILE_MODE_READ:
-				handle = PHYSFS_openRead(mFileName.c_str());
+				handle = PHYSFS_openRead(m_FileName.c_str());
 				break;
 			case FILE_MODE_APPEND:
-				handle = PHYSFS_openAppend(mFileName.c_str());
+				handle = PHYSFS_openAppend(m_FileName.c_str());
 				break;
 			case FILE_MODE_WRITE:
-				handle = PHYSFS_openWrite(mFileName.c_str());
+				handle = PHYSFS_openWrite(m_FileName.c_str());
 				break;
 			}
 
@@ -77,45 +77,45 @@ namespace AsuraEngine
 				const char *err = PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode());
 				if (err == nullptr)
 					err = "unknown error";
-				throw Exception("Could not open file %s (%s)", mFileName.c_str(), err);
+				throw Exception("Could not open file %s (%s)", m_FileName.c_str(), err);
 			}
 
-			mFileHandle = handle;
-			mMode = mode; 
+		 m_FileHandle = handle;
+		 m_Mode = mode; 
 
-			if (mFileHandle && !SetBuffer(mBufferMode,mBufferSize))
+			if (m_FileHandle && !SetBuffer(m_BufferMode,m_BufferSize))
 			{
-				mBufferMode = BUFFER_MODE_NONE; 
-				mBufferSize = 0;
+			 m_BufferMode = BUFFER_MODE_NONE; 
+			 m_BufferSize = 0;
 			}
 
-			return mFileHandle != nullptr;
+			return m_FileHandle != nullptr;
 		}
 
 		bool File::Close()
 		{
-			if (mFileHandle == nullptr || !PHYSFS_close(mFileHandle))
+			if (m_FileHandle == nullptr || !PHYSFS_close(m_FileHandle))
 				return false;
-			mMode = FILE_MODE_CLOSED;
-			mFileHandle = nullptr;
+		 m_Mode = FILE_MODE_CLOSED;
+		 m_FileHandle = nullptr;
 			return true;
 		}
 
 		bool File::IsOpen()
 		{
-			return mMode != FILE_MODE_CLOSED && mFileHandle != nullptr;
+			return m_Mode != FILE_MODE_CLOSED && m_FileHandle != nullptr;
 		}
 
 		size_t File::GetSize()
 		{
-			if (mFileHandle == nullptr)
+			if (m_FileHandle == nullptr)
 			{
 				Open(FILE_MODE_READ);
-				size_t size = PHYSFS_fileLength(mFileHandle);
+				size_t size = PHYSFS_fileLength(m_FileHandle);
 				Close(); 
 				return size;
 			}
-			return PHYSFS_fileLength(mFileHandle);
+			return PHYSFS_fileLength(m_FileHandle);
 		}
 
 		size_t File::Read(ASURA_OUT DataBuffer* dst, size_t length)
@@ -125,17 +125,17 @@ namespace AsuraEngine
 			if (dst->GetCapacity() < length)
 				throw Exception("Data buffer is too small compares to read length.");
 
-			if (!mFileHandle || mMode != FILE_MODE_READ)
-				throw Exception("File \"%s\" is not opened for reading", mFileName);
+			if (!m_FileHandle || m_Mode != FILE_MODE_READ)
+				throw Exception("File \"%s\" is not opened for reading", m_FileName);
 
-			size_t max = PHYSFS_fileLength(mFileHandle);
+			size_t max = PHYSFS_fileLength(m_FileHandle);
 			length = (length > max) ? max : length;
 
 			if (length < 0)
 				throw Exception("Invalid read size.");
 
 			dst->Lock();
-			size_t size = PHYSFS_readBytes(mFileHandle, dst->GetData(), length);
+			size_t size = PHYSFS_readBytes(m_FileHandle, dst->GetData(), length);
 			dst->Unlock();
 			return size;
 		}
@@ -144,17 +144,17 @@ namespace AsuraEngine
 		{
 			ASSERT(dst);
 
-			if (!mFileHandle || mMode != FILE_MODE_READ)
-				throw Exception("File \"%s\" is not opened for reading", mFileName);
+			if (!m_FileHandle || m_Mode != FILE_MODE_READ)
+				throw Exception("File \"%s\" is not opened for reading", m_FileName);
 
-			size_t length = PHYSFS_fileLength(mFileHandle);
+			size_t length = PHYSFS_fileLength(m_FileHandle);
 
 			if (dst->GetCapacity() < length)
 				throw Exception("Data buffer is too small compares to file length.");
 
 			dst->Lock();
 			byte* data = dst->GetData();
-			size_t size = PHYSFS_readBytes(mFileHandle, data, length);
+			size_t size = PHYSFS_readBytes(m_FileHandle, data, length);
 			dst->Move(data, length);
 			dst->Unlock();
 			return size;
@@ -176,25 +176,25 @@ namespace AsuraEngine
 
 		bool File::IsEOF()
 		{
-			return mFileHandle == nullptr || test_eof(this, mFileHandle);
+			return m_FileHandle == nullptr || test_eof(this, m_FileHandle);
 		}
 
 		size_t File::Tell()
 		{
-			if (!mFileHandle)
+			if (!m_FileHandle)
 				return - 1;
 
-			return PHYSFS_tell(mFileHandle);
+			return PHYSFS_tell(m_FileHandle);
 		}
 
 		bool File::Seek(size_t pos)
 		{
-			return mFileHandle != nullptr && PHYSFS_seek(mFileHandle, pos) != 0;
+			return m_FileHandle != nullptr && PHYSFS_seek(m_FileHandle, pos) != 0;
 		}
 
 		bool File::Write(ASURA_REF DataBuffer* src)
 		{
-			if (!mFileHandle || (mMode != FILE_MODE_APPEND && mMode != FILE_MODE_WRITE))
+			if (!m_FileHandle || (m_Mode != FILE_MODE_APPEND && m_Mode != FILE_MODE_WRITE))
 				throw Exception("File is not opened for writing.");
 
 			byte* data = src->GetData();
@@ -203,13 +203,13 @@ namespace AsuraEngine
 			if (size < 0)
 				throw Exception("Invalid write size.");
 
-			size_t written = PHYSFS_writeBytes(mFileHandle, data, size);
+			size_t written = PHYSFS_writeBytes(m_FileHandle, data, size);
 
 			if (written != src->GetSize())
 				return false; 
 
 			// �������
-			if (mBufferSize == BUFFER_MODE_LINE && mBufferSize > size)
+			if (m_BufferSize == BUFFER_MODE_LINE && m_BufferSize > size)
 			{
 				if (memchr(data, '\n', size) != nullptr)
 					Flush();
@@ -220,10 +220,10 @@ namespace AsuraEngine
 
 		bool File::Flush()
 		{
-			if (!mFileHandle || (mMode != FILE_MODE_WRITE && mMode != FILE_MODE_APPEND))
+			if (!m_FileHandle || (m_Mode != FILE_MODE_WRITE && m_Mode != FILE_MODE_APPEND))
 				throw Exception("File is not opened for writing.");
 
-			return PHYSFS_flush(mFileHandle) != 0;
+			return PHYSFS_flush(m_FileHandle) != 0;
 		}
 
 		bool File::SetBuffer(BufferMode mode, size_t size)
@@ -235,8 +235,8 @@ namespace AsuraEngine
 			// File::open.
 			if (!IsOpen())
 			{
-				mBufferMode = mode;
-				mBufferSize = size;
+			 m_BufferMode = mode;
+			 m_BufferSize = size;
 				return true;
 			}
 
@@ -246,48 +246,48 @@ namespace AsuraEngine
 			{
 			case BUFFER_MODE_NONE:
 			default:
-				ret = PHYSFS_setBuffer(mFileHandle, 0);
+				ret = PHYSFS_setBuffer(m_FileHandle, 0);
 				size = 0;
 				break;
 			case BUFFER_MODE_LINE:
 			case BUFFER_MODE_FULL:
-				ret = PHYSFS_setBuffer(mFileHandle, size);
+				ret = PHYSFS_setBuffer(m_FileHandle, size);
 				break;
 			}
 
 			if (ret == 0)
 				return false;
 
-			mBufferMode = mode;
-			mBufferSize = size;
+		 m_BufferMode = mode;
+		 m_BufferSize = size;
 
 			return true;
 		}
 
 		File::BufferMode File::GetBuffer(ASURA_OUT size_t& size) 
 		{
-			size = mBufferSize; 
-			return mBufferMode; 
+			size = m_BufferSize; 
+			return m_BufferMode; 
 		}
 
 		const std::string& File::GetFileName()
 		{
-			return mFileName;
+			return m_FileName;
 		}
 
 		const std::string& File::GetName()
 		{
-			return mName;
+			return m_Name;
 		}
 
 		const std::string& File::GetExtension()
 		{
-			return mExtension;
+			return m_Extension;
 		}
 
 		File::FileMode File::GetMode()
 		{
-			return mMode;
+			return m_Mode;
 		}
 
 	}