Index: src/libchcore/TSharedMemory.cpp
===================================================================
diff -u -N -r68ef7c89b475edd21eac083b8d22660e15f97254 -re96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3
--- src/libchcore/TSharedMemory.cpp	(.../TSharedMemory.cpp)	(revision 68ef7c89b475edd21eac083b8d22660e15f97254)
+++ src/libchcore/TSharedMemory.cpp	(.../TSharedMemory.cpp)	(revision e96806b7f8ff7ca7e9f4afbea603e6351a3dc3e3)
@@ -26,237 +26,236 @@
 #include "ErrorCodes.h"
 #include "TCoreException.h"
 
-BEGIN_CHCORE_NAMESPACE
-
+namespace chcore
+{
 #define MUTEX_SUFFIX _T("_Mutex")
 
-class TMutexLock
-{
-public:
-	TMutexLock(HANDLE hMutex) :
-		m_hMutex(hMutex)
+	class TMutexLock
 	{
-		if(m_hMutex)
+	public:
+		TMutexLock(HANDLE hMutex) :
+			m_hMutex(hMutex)
 		{
-			DWORD dwRes = WaitForSingleObject(hMutex, 10000);
-			if(dwRes != WAIT_OBJECT_0)
-				THROW_CORE_EXCEPTION(eErr_MutexTimedOut);
+			if (m_hMutex)
+			{
+				DWORD dwRes = WaitForSingleObject(hMutex, 10000);
+				if (dwRes != WAIT_OBJECT_0)
+					THROW_CORE_EXCEPTION(eErr_MutexTimedOut);
+			}
 		}
+
+		~TMutexLock()
+		{
+			if (m_hMutex)
+				ReleaseMutex(m_hMutex);
+		}
+
+	private:
+		HANDLE m_hMutex;
+	};
+
+	///////////////////////////////////////////////////////////////////////////////////////
+	// TSharedMemory class
+
+	TSharedMemory::TSharedMemory() :
+		m_hFileMapping(NULL),
+		m_pMappedMemory(NULL),
+		m_hMutex(NULL),
+		m_stSize(0)
+	{
 	}
 
-	~TMutexLock()
+	TSharedMemory::~TSharedMemory()
 	{
-		if(m_hMutex)
-			ReleaseMutex(m_hMutex);
+		Close();
 	}
 
-private:
-	HANDLE m_hMutex;
-};
+	void TSharedMemory::Create(const wchar_t* pszName, shm_size_t stSize)
+	{
+		if (!pszName || pszName[0] == _T('\0') || stSize == 0)
+			THROW_CORE_EXCEPTION(eErr_InvalidArgument);
 
-///////////////////////////////////////////////////////////////////////////////////////
-// TSharedMemory class
+		Close();
 
-TSharedMemory::TSharedMemory() :
-	m_hFileMapping(NULL),
-	m_pMappedMemory(NULL),
-	m_hMutex(NULL),
-	m_stSize(0)
-{
-}
+		try
+		{
+			std::wstring wstrMutexName = pszName;
+			wstrMutexName += MUTEX_SUFFIX;
 
-TSharedMemory::~TSharedMemory()
-{
-	Close();
-}
+			SECURITY_DESCRIPTOR secDesc;
+			if (!InitializeSecurityDescriptor(&secDesc, SECURITY_DESCRIPTOR_REVISION))
+				THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
 
-void TSharedMemory::Create(const wchar_t* pszName, shm_size_t stSize)
-{
-	if(!pszName || pszName[0] == _T('\0') || stSize == 0)
-		THROW_CORE_EXCEPTION(eErr_InvalidArgument);
+			SECURITY_ATTRIBUTES secAttr;
+			secAttr.nLength = sizeof(secAttr);
+			secAttr.bInheritHandle = FALSE;
+			secAttr.lpSecurityDescriptor = &secDesc;
 
-	Close();
+			if (!SetSecurityDescriptorDacl(secAttr.lpSecurityDescriptor, TRUE, 0, FALSE))
+				THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
 
-	try
-	{
-		std::wstring wstrMutexName = pszName;
-		wstrMutexName += MUTEX_SUFFIX;
+			m_hMutex = ::CreateMutex(&secAttr, FALSE, wstrMutexName.c_str());
+			if (!m_hMutex)
+				THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
 
-		SECURITY_DESCRIPTOR secDesc;
-		if(!InitializeSecurityDescriptor(&secDesc, SECURITY_DESCRIPTOR_REVISION))
-			THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
+			m_hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, &secAttr, PAGE_READWRITE, 0, boost::numeric_cast<DWORD>(stSize + sizeof(size_t)), pszName);
+			if (!m_hFileMapping)
+				THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
+			else if (GetLastError() == ERROR_ALREADY_EXISTS)
+				THROW_CORE_EXCEPTION(eErr_SharedMemoryAlreadyExists);		// shared memory already exists - cannot guarantee that the size is correct
 
-		SECURITY_ATTRIBUTES secAttr;
-		secAttr.nLength = sizeof(secAttr);
-		secAttr.bInheritHandle = FALSE;
-		secAttr.lpSecurityDescriptor = &secDesc;
+			// Get a pointer to the file-mapped shared memory.
+			m_pMappedMemory = (BYTE*)MapViewOfFile(m_hFileMapping, FILE_MAP_WRITE, 0, 0, 0);
+			if (!m_pMappedMemory)
+				THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
+		}
+		catch (...)
+		{
+			Close();
+			throw;
+		}
 
-		if(!SetSecurityDescriptorDacl(secAttr.lpSecurityDescriptor, TRUE, 0, FALSE))
-			THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
+		TMutexLock lock(m_hMutex);
 
-		m_hMutex = ::CreateMutex(&secAttr, FALSE, wstrMutexName.c_str());
-		if(!m_hMutex)
-			THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
-
-		m_hFileMapping = CreateFileMapping(INVALID_HANDLE_VALUE, &secAttr, PAGE_READWRITE, 0, boost::numeric_cast<DWORD>(stSize + sizeof(size_t)), pszName);
-		if(!m_hFileMapping) 
-			THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
-		else if(GetLastError() == ERROR_ALREADY_EXISTS)
-			THROW_CORE_EXCEPTION(eErr_SharedMemoryAlreadyExists);		// shared memory already exists - cannot guarantee that the size is correct
-
-		// Get a pointer to the file-mapped shared memory.
-		m_pMappedMemory = (BYTE*)MapViewOfFile(m_hFileMapping, FILE_MAP_WRITE, 0, 0, 0);
-		if(!m_pMappedMemory)
-			THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
+		m_stSize = stSize + sizeof(shm_size_t);
+		*(shm_size_t*)m_pMappedMemory = sizeof(shm_size_t);  // no data inside (set just in case)
 	}
-	catch(...)
+
+	void TSharedMemory::Create(const wchar_t* pszName, const TString& wstrData)
 	{
-		Close();
-		throw;
+		Create(pszName, (const BYTE*)wstrData.c_str(), boost::numeric_cast<shm_size_t>((wstrData.GetLength() + 1) * sizeof(wchar_t)));
 	}
 
-	TMutexLock lock(m_hMutex);
+	void TSharedMemory::Create(const wchar_t* pszName, const BYTE* pbyData, shm_size_t stSize)
+	{
+		Create(pszName, stSize);
 
-	m_stSize = stSize + sizeof(shm_size_t);
-	*(shm_size_t*)m_pMappedMemory = sizeof(shm_size_t);  // no data inside (set just in case)
-}
+		TMutexLock lock(m_hMutex);
 
-void TSharedMemory::Create(const wchar_t* pszName, const TString& wstrData)
-{
-	Create(pszName, (const BYTE*)wstrData.c_str(), boost::numeric_cast<shm_size_t>((wstrData.GetLength() + 1) * sizeof(wchar_t)));
-}
+		*(shm_size_t*)m_pMappedMemory = stSize;
+		memcpy(m_pMappedMemory + sizeof(shm_size_t), pbyData, stSize);
+	}
 
-void TSharedMemory::Create(const wchar_t* pszName, const BYTE* pbyData, shm_size_t stSize)
-{
-	Create(pszName, stSize);
+	void TSharedMemory::Open(const wchar_t* pszName)
+	{
+		Close();
 
-	TMutexLock lock(m_hMutex);
+		try
+		{
+			m_hFileMapping = OpenFileMapping(FILE_MAP_READ, FALSE, pszName);
+			if (!m_hFileMapping)
+				THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
 
-	*(shm_size_t*)m_pMappedMemory = stSize;
-	memcpy(m_pMappedMemory + sizeof(shm_size_t), pbyData, stSize);
-}
+			// Get a pointer to the file-mapped shared memory.
+			m_pMappedMemory = (BYTE*)MapViewOfFile(m_hFileMapping, FILE_MAP_READ, 0, 0, 0);
+			if (!m_pMappedMemory)
+				THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
+		}
+		catch (...)
+		{
+			Close();
+			throw;
+		}
 
-void TSharedMemory::Open(const wchar_t* pszName)
-{
-	Close();
+		TMutexLock lock(m_hMutex);
 
-	try
-	{
-		m_hFileMapping = OpenFileMapping(FILE_MAP_READ, FALSE, pszName);
-		if(!m_hFileMapping) 
-			THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
-
-		// Get a pointer to the file-mapped shared memory.
-		m_pMappedMemory = (BYTE*)MapViewOfFile(m_hFileMapping, FILE_MAP_READ, 0, 0, 0);
-		if(!m_pMappedMemory)
-			THROW_CORE_EXCEPTION(eErr_CannotOpenSharedMemory);
+		m_stSize = *(shm_size_t*)m_pMappedMemory + sizeof(shm_size_t);
 	}
-	catch(...)
-	{
-		Close();
-		throw;
-	}
 
-	TMutexLock lock(m_hMutex);
-
-	m_stSize = *(shm_size_t*)m_pMappedMemory + sizeof(shm_size_t);
-}
-
-void TSharedMemory::Close() throw()
-{
-	try
+	void TSharedMemory::Close() throw()
 	{
-		if(m_hMutex)
+		try
 		{
-			CloseHandle(m_hMutex);
-			m_hMutex = NULL;
-		}
+			if (m_hMutex)
+			{
+				CloseHandle(m_hMutex);
+				m_hMutex = NULL;
+			}
 
-		if(m_pMappedMemory)
-		{
-			UnmapViewOfFile(m_pMappedMemory);
-			m_pMappedMemory = NULL;
-		}
+			if (m_pMappedMemory)
+			{
+				UnmapViewOfFile(m_pMappedMemory);
+				m_pMappedMemory = NULL;
+			}
 
-		// Close the process's handle to the file-mapping object.
-		if(m_hFileMapping)
+			// Close the process's handle to the file-mapping object.
+			if (m_hFileMapping)
+			{
+				CloseHandle(m_hFileMapping);
+				m_hFileMapping = NULL;
+			}
+		}
+		catch (...)
 		{
-			CloseHandle(m_hFileMapping);
-			m_hFileMapping = NULL;
 		}
 	}
-	catch(...)
+
+	void TSharedMemory::Read(TString& wstrData) const
 	{
-	}
-}
+		if (!m_hFileMapping || !m_pMappedMemory || m_stSize <= sizeof(shm_size_t))
+			THROW_CORE_EXCEPTION(eErr_SharedMemoryNotOpen);
 
-void TSharedMemory::Read(TString& wstrData) const
-{
-	if(!m_hFileMapping || !m_pMappedMemory || m_stSize <= sizeof(shm_size_t))
-		THROW_CORE_EXCEPTION(eErr_SharedMemoryNotOpen);
+		TMutexLock lock(m_hMutex);
 
-	TMutexLock lock(m_hMutex);
+		shm_size_t stByteSize = *(shm_size_t*)m_pMappedMemory;
+		if ((stByteSize % 2) != 0)
+			THROW_CORE_EXCEPTION(eErr_SharedMemoryInvalidFormat);
 
-	shm_size_t stByteSize = *(shm_size_t*)m_pMappedMemory;
-	if((stByteSize % 2) != 0)
-		THROW_CORE_EXCEPTION(eErr_SharedMemoryInvalidFormat);
+		const wchar_t* pszRealData = (const wchar_t*)(m_pMappedMemory + sizeof(shm_size_t));
+		shm_size_t stCharCount = stByteSize / 2;
 
-	const wchar_t* pszRealData = (const wchar_t*)(m_pMappedMemory + sizeof(shm_size_t));
-	shm_size_t stCharCount = stByteSize / 2;
+		if (pszRealData[stCharCount - 1] != _T('\0'))
+			THROW_CORE_EXCEPTION(eErr_SharedMemoryInvalidFormat);
 
-	if(pszRealData[stCharCount - 1] != _T('\0'))
-		THROW_CORE_EXCEPTION(eErr_SharedMemoryInvalidFormat);
+		wstrData = pszRealData;
+	}
 
-	wstrData = pszRealData;
-}
+	void TSharedMemory::Write(const TString& wstrData)
+	{
+		Write((const BYTE*)wstrData.c_str(), boost::numeric_cast<shm_size_t>((wstrData.GetLength() + 1) * sizeof(wchar_t)));
+	}
 
-void TSharedMemory::Write(const TString& wstrData)
-{
-	Write((const BYTE*)wstrData.c_str(), boost::numeric_cast<shm_size_t>((wstrData.GetLength() + 1) * sizeof(wchar_t)));
-}
+	void TSharedMemory::Write(const BYTE* pbyData, shm_size_t stSize)
+	{
+		if (stSize + sizeof(shm_size_t) > m_stSize)
+			THROW_CORE_EXCEPTION(eErr_BoundsExceeded);
 
-void TSharedMemory::Write(const BYTE* pbyData, shm_size_t stSize)
-{
-	if(stSize + sizeof(shm_size_t) > m_stSize)
-		THROW_CORE_EXCEPTION(eErr_BoundsExceeded);
+		TMutexLock lock(m_hMutex);
 
-	TMutexLock lock(m_hMutex);
+		*(shm_size_t*)m_pMappedMemory = stSize;
+		memcpy(m_pMappedMemory + sizeof(shm_size_t), pbyData, stSize);
+	}
 
-	*(shm_size_t*)m_pMappedMemory = stSize;
-	memcpy(m_pMappedMemory + sizeof(shm_size_t), pbyData, stSize);
-}
+	const BYTE* TSharedMemory::GetData() const
+	{
+		if (!m_hFileMapping || !m_pMappedMemory || m_stSize <= sizeof(shm_size_t))
+			return NULL;
 
-const BYTE* TSharedMemory::GetData() const
-{
-	if(!m_hFileMapping || !m_pMappedMemory || m_stSize <= sizeof(shm_size_t))
-		return NULL;
+		return (BYTE*)m_pMappedMemory + sizeof(shm_size_t);
+	}
 
-	return (BYTE*)m_pMappedMemory + sizeof(shm_size_t);
-}
+	BYTE* TSharedMemory::GetData()
+	{
+		if (!m_hFileMapping || !m_pMappedMemory || m_stSize <= sizeof(shm_size_t))
+			return NULL;
 
-BYTE* TSharedMemory::GetData()
-{
-	if(!m_hFileMapping || !m_pMappedMemory || m_stSize <= sizeof(shm_size_t))
-		return NULL;
+		return (BYTE*)m_pMappedMemory + sizeof(shm_size_t);
+	}
 
-	return (BYTE*)m_pMappedMemory + sizeof(shm_size_t);
-}
+	TSharedMemory::shm_size_t TSharedMemory::GetSharedMemorySize() const
+	{
+		if (!m_hFileMapping || !m_pMappedMemory)
+			return 0;
+		return m_stSize;
+	}
 
-TSharedMemory::shm_size_t TSharedMemory::GetSharedMemorySize() const
-{
-	if(!m_hFileMapping || !m_pMappedMemory)
-		return 0;
-	return m_stSize;
-}
+	TSharedMemory::shm_size_t TSharedMemory::GetDataSize() const
+	{
+		if (!m_hFileMapping || !m_pMappedMemory || m_stSize <= sizeof(shm_size_t))
+			return 0;
 
-TSharedMemory::shm_size_t TSharedMemory::GetDataSize() const
-{
-	if(!m_hFileMapping || !m_pMappedMemory || m_stSize <= sizeof(shm_size_t))
-		return 0;
+		TMutexLock lock(m_hMutex);
 
-	TMutexLock lock(m_hMutex);
-
-	return *(shm_size_t*)m_pMappedMemory;
+		return *(shm_size_t*)m_pMappedMemory;
+	}
 }
-
-END_CHCORE_NAMESPACE