cWorld Threads: Seperate initialization and thread start.

Prevents nullptr dereferences before Start has been called.
424ever · Oct 21, 2017 · c54bf40 · c54bf40
1 parent 1537ebe
commit c54bf40
Show file tree

Hide file tree

Showing 6 changed files with 17 additions and 32 deletions.
diff --git a/src/LightingThread.cpp b/src/LightingThread.cpp
@@ -88,9 +88,9 @@ class cReader :
 ////////////////////////////////////////////////////////////////////////////////
 // cLightingThread:
 
-cLightingThread::cLightingThread(void) :
+cLightingThread::cLightingThread(cWorld & a_World):
 	super("cLightingThread"),
-	m_World(nullptr),
+	m_World(a_World),
 	m_MaxHeight(0),
 	m_NumSeeds(0)
 {
@@ -109,18 +109,6 @@ cLightingThread::~cLightingThread()
 
 
 
-bool cLightingThread::Start(cWorld * a_World)
-{
-	ASSERT(m_World == nullptr);  // Not started yet
-	m_World = a_World;
-
-	return super::Start();
-}
-
-
-
-
-
 void cLightingThread::Stop(void)
 {
 	{
@@ -150,16 +138,14 @@ void cLightingThread::Stop(void)
 
 void cLightingThread::QueueChunk(int a_ChunkX, int a_ChunkZ, std::unique_ptr<cChunkCoordCallback> a_CallbackAfter)
 {
-	ASSERT(m_World != nullptr);  // Did you call Start() properly?
-
 	cChunkStay * ChunkStay = new cLightingChunkStay(*this, a_ChunkX, a_ChunkZ, std::move(a_CallbackAfter));
 	{
 		// The ChunkStay will enqueue itself using the QueueChunkStay() once it is fully loaded
 		// In the meantime, put it into the PendingQueue so that it can be removed when stopping the thread
 		cCSLock Lock(m_CS);
 		m_PendingQueue.push_back(ChunkStay);
 	}
-	ChunkStay->Enable(*m_World->GetChunkMap());
+	ChunkStay->Enable(*m_World.GetChunkMap());
 }
 
 
@@ -238,7 +224,7 @@ void cLightingThread::Execute(void)
 void cLightingThread::LightChunk(cLightingChunkStay & a_Item)
 {
 	// If the chunk is already lit, skip it (report as success):
-	if (m_World->IsChunkLighted(a_Item.m_ChunkX, a_Item.m_ChunkZ))
+	if (m_World.IsChunkLighted(a_Item.m_ChunkX, a_Item.m_ChunkZ))
 	{
 		if (a_Item.m_CallbackAfter != nullptr)
 		{
@@ -319,7 +305,7 @@ void cLightingThread::LightChunk(cLightingChunkStay & a_Item)
 	CompressLight(m_BlockLight, BlockLight);
 	CompressLight(m_SkyLight, SkyLight);
 
-	m_World->ChunkLighted(a_Item.m_ChunkX, a_Item.m_ChunkZ, BlockLight, SkyLight);
+	m_World.ChunkLighted(a_Item.m_ChunkX, a_Item.m_ChunkZ, BlockLight, SkyLight);
 
 	if (a_Item.m_CallbackAfter != nullptr)
 	{
@@ -341,7 +327,7 @@ void cLightingThread::ReadChunks(int a_ChunkX, int a_ChunkZ)
 		for (int x = 0; x < 3; x++)
 		{
 			Reader.m_ReadingChunkX = x;
-			VERIFY(m_World->GetChunkData(a_ChunkX + x - 1, a_ChunkZ + z - 1, Reader));
+			VERIFY(m_World.GetChunkData(a_ChunkX + x - 1, a_ChunkZ + z - 1, Reader));
 		}  // for z
 	}  // for x
 

diff --git a/src/LightingThread.h b/src/LightingThread.h
@@ -52,11 +52,9 @@ class cLightingThread :
 
 public:
 
-	cLightingThread(void);
+	cLightingThread(cWorld & a_World);
 	virtual ~cLightingThread() override;
 
-	bool Start(cWorld * a_World);
-
 	void Stop(void);
 
 	/** Queues the entire chunk for lighting.
@@ -94,7 +92,7 @@ class cLightingThread :
 	typedef std::list<cChunkStay *> cChunkStays;
 
 
-	cWorld * m_World;
+	cWorld & m_World;
 
 	/** The mutex to protect m_Queue and m_PendingQueue */
 	cCriticalSection m_CS;

diff --git a/src/World.cpp b/src/World.cpp
@@ -196,6 +196,7 @@ cWorld::cWorld(
 	m_MapManager(this),
 	m_GeneratorCallbacks(*this),
 	m_ChunkSender(*this),
+	m_Lighting(*this),
 	m_TickThread(*this)
 {
 	LOGD("cWorld::cWorld(\"%s\")", a_WorldName.c_str());
@@ -405,6 +406,7 @@ cWorld::cWorld(
 	m_SimulatorManager->RegisterSimulator(m_SandSimulator.get(), 1);
 	m_SimulatorManager->RegisterSimulator(m_FireSimulator.get(), 1);
 
+	m_Storage.Initialize(*this, m_StorageSchema, m_StorageCompressionFactor);
 	m_Generator.Initialize(m_GeneratorCallbacks, m_GeneratorCallbacks, IniFile);
 
 	m_MapManager.LoadMapData();
@@ -607,8 +609,8 @@ void cWorld::InitializeSpawn(void)
 
 void cWorld::Start()
 {
-	m_Lighting.Start(this);
-	m_Storage.Start(this, m_StorageSchema, m_StorageCompressionFactor);
+	m_Lighting.Start();
+	m_Storage.Start();
 	m_Generator.Start();
 	m_ChunkSender.Start();
 	m_TickThread.Start();

diff --git a/src/World.h b/src/World.h
@@ -962,7 +962,7 @@ class cWorld :
 	cCriticalSection m_CSPlayers;
 	cPlayerList      m_Players;
 
-	cWorldStorage     m_Storage;
+	cWorldStorage    m_Storage;
 
 	unsigned int m_MaxPlayers;
 

diff --git a/src/WorldStorage/WorldStorage.cpp b/src/WorldStorage/WorldStorage.cpp
@@ -60,13 +60,11 @@ cWorldStorage::~cWorldStorage()
 
 
 
-bool cWorldStorage::Start(cWorld * a_World, const AString & a_StorageSchemaName, int a_StorageCompressionFactor)
+void cWorldStorage::Initialize(cWorld & a_World, const AString & a_StorageSchemaName, int a_StorageCompressionFactor)
 {
-	m_World = a_World;
+	m_World = &a_World;
 	m_StorageSchemaName = a_StorageSchemaName;
 	InitSchemas(a_StorageCompressionFactor);
-
-	return super::Start();
 }
 
 

diff --git a/src/WorldStorage/WorldStorage.h b/src/WorldStorage/WorldStorage.h
@@ -69,7 +69,8 @@ class cWorldStorage :
 	The callback, if specified, will be called with the result of the save operation. */
 	void QueueSaveChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_Callback = nullptr);
 
-	bool Start(cWorld * a_World, const AString & a_StorageSchemaName, int a_StorageCompressionFactor);  // Hide the cIsThread's Start() method, we need to provide args
+	/** Initializes the storage schemas, ready to be started. */
+	void Initialize(cWorld & a_World, const AString & a_StorageSchemaName, int a_StorageCompressionFactor);
 	void Stop(void);  // Hide the cIsThread's Stop() method, we need to signal the event
 	void WaitForFinish(void);
 	void WaitForLoadQueueEmpty(void);