Merge (the hardest merge evahr, thanks rude)

src/modules/thread/ThreadModule.h

@@ -0,0 +1,41 @@
+/**
+* Copyright (c) 2006-2010 LOVE Development Team
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+*
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+*
+* 1. The origin of this software must not be misrepresented; you must not
+*    claim that you wrote the original software. If you use this software
+*    in a product, an acknowledgment in the product documentation would be
+*    appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+*    misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+**/
+
+#ifndef LOVE_THREAD_THREAD_H
+#define LOVE_THREAD_THREAD_H
+
+#include <common/Module.h>
+#include <string>
+
+namespace love
+{
+namespace thread
+{
+	class ThreadModule : public Module
+	{
+	public:
+		virtual ~ThreadModule(){};
+		virtual void unregister(const std::string & name) = 0;
+	}; // ThreadModule
+
+} // thread
+} // love
+
+#endif // LOVE_THREAD_THREAD_H

src/modules/thread/sdl/Thread.cpp

@@ -43,7 +43,7 @@ namespace sdl
 	#endif // LOVE_BUILD_STANDALONE
 		luaopen_love_thread(L);
 		lua_pushstring(L, comm->getName());
-		luax_convobj(L, lua_gettop(L), "thread", "getThread");
+ 		luax_convobj(L, lua_gettop(L), "thread", "getThread");
 		lua_getglobal(L, "love");
 		lua_pushvalue(L, -2);
 		lua_setfield(L, -2, "_curthread");
@@ -143,14 +143,14 @@ namespace sdl
 		return name;
 	}
 
-	ThreadVariant* ThreadData::getValue(std::string name)
+	ThreadVariant* ThreadData::getValue(const std::string & name)
 	{
 		if (shared.count(name) == 0)
 			return 0;
 		return shared[name];
 	}
 
-	void ThreadData::clearValue(std::string name)
+	void ThreadData::clearValue(const std::string & name)
 	{
 		if (shared.count(name) == 0)
 			return;
@@ -158,7 +158,7 @@ namespace sdl
 		shared.erase(name);
 	}
 
-	void ThreadData::setValue(std::string name, ThreadVariant *v)
+	void ThreadData::setValue(const std::string & name, ThreadVariant *v)
 	{
 		if (shared.count(name) != 0)
 			shared[name]->release();
@@ -166,10 +166,10 @@ namespace sdl
 		shared[name] = v;
 	}
 
-	Thread::Thread(ThreadModuleRegistrar *reg, std::string name, love::Data *data)
-		: handle(0), reg(reg), name(name), isThread(true)
+	Thread::Thread(love::thread::ThreadModule *module, const std::string & name, love::Data *data)
+		: handle(0), module(module), name(name), isThread(true)
 	{
-		reg->retain();
+		module->retain();
 		unsigned int len = data->getSize();
 		this->data = new char[len+1];
 		memset(this->data, 0, len+1);
@@ -179,10 +179,10 @@ namespace sdl
 		cond = SDL_CreateCond();
 	}
 
-	Thread::Thread(ThreadModuleRegistrar *reg, std::string name)
-		: handle(0), reg(reg), name(name), data(0), isThread(false)
+	Thread::Thread(love::thread::ThreadModule *module, const std::string & name)
+		: handle(0), module(module), name(name), data(0), isThread(false)
 	{
-		reg->retain();
+		module->retain();
 		comm = new ThreadData(name.c_str(), NULL);
 		mutex = SDL_CreateMutex();
 		cond = SDL_CreateCond();
@@ -195,10 +195,10 @@ namespace sdl
 		delete comm;
 		if (handle)
 			SDL_KillThread(handle);
-		reg->unregister(name);
+		module->unregister(name);
 		SDL_DestroyMutex(mutex);
 		SDL_DestroyCond(cond);
-		reg->release();
+		module->release();
 	}
 
 	void Thread::start()
@@ -240,7 +240,7 @@ namespace sdl
 		return name;
 	}
 
-	ThreadVariant *Thread::receive(std::string name)
+	ThreadVariant *Thread::receive(const std::string & name)
 	{
 		lock();
 		ThreadVariant *v = comm->getValue(name);
@@ -248,7 +248,7 @@ namespace sdl
 		return v;
 	}
 
-	ThreadVariant *Thread::demand(std::string name)
+	ThreadVariant *Thread::demand(const std::string & name)
 	{
 		lock();
 		ThreadVariant *v = comm->getValue(name);
@@ -263,14 +263,14 @@ namespace sdl
 		return v;
 	}
 
-	void Thread::clear(std::string name)
+	void Thread::clear(const std::string & name)
 	{
 		lock();
 		comm->clearValue(name);
 		unlock();
 	}
 
-	void Thread::send(std::string name, ThreadVariant *v)
+	void Thread::send(const std::string & name, ThreadVariant *v)
 	{
 		lock();
 		comm->setValue(name, v);
@@ -291,7 +291,7 @@ namespace sdl
 		}
 	}
 
-	Thread *ThreadModule::newThread(std::string name, love::Data *data)
+	Thread *ThreadModule::newThread(const std::string & name, love::Data *data)
 	{
 		if (threads.count(name) != 0)
 			return 0;
@@ -300,7 +300,7 @@ namespace sdl
 		return t;
 	}
 
-	Thread *ThreadModule::getThread(std::string name)
+	Thread *ThreadModule::getThread(const std::string & name)
 	{
 		if (threads.count(name) == 0)
 			return 0;
@@ -308,19 +308,21 @@ namespace sdl
 		return i->second;
 	}
 
-	Thread **ThreadModule::getThreads()
+	void ThreadModule::getThreads(Thread ** list)
 	{
-		Thread **list = new Thread*[threads.size()+1];
 		int c = 0;
 		for (threadlist_t::iterator i = threads.begin(); i != threads.end(); i++, c++)
 		{
 			list[c] = i->second;
 		}
-		list[threads.size()] = 0;
-		return list;
 	}
 
-	void ThreadModule::unregister(std::string name)
+	unsigned ThreadModule::getThreadCount() const
+	{
+		return threads.size();
+	}
+
+	void ThreadModule::unregister(const std::string & name)
 	{
 		if (threads.count(name) == 0)
 			return;

src/modules/thread/sdl/Thread.h

@@ -18,8 +18,8 @@
 * 3. This notice may not be removed or altered from any source distribution.
 **/
 
-#ifndef LOVE_THREAD_THREAD_H
-#define LOVE_THREAD_THREAD_H
+#ifndef LOVE_THREAD_SDL_THREAD_H
+#define LOVE_THREAD_SDL_THREAD_H
 
 // SDL
 #include <SDL_thread.h>
@@ -30,7 +30,7 @@
 #include <string>
 
 // LOVE
-#include <common/Module.h>
+#include <thread/ThreadModule.h>
 #include <filesystem/File.h>
 #include <common/runtime.h>
 
@@ -40,12 +40,6 @@ namespace thread
 {
 namespace sdl
 {
-	class ThreadModuleRegistrar : public Module
-	{
-	public:
-		virtual void unregister(std::string name) = 0;
-	};
-
 	enum ThreadVariantType
 	{
 		UNKNOWN = 0,
@@ -64,7 +58,7 @@ namespace sdl
 		ThreadVariant(const char *string);
 		ThreadVariant(void *userdata);
 		ThreadVariant(Type udatatype, void *userdata);
-		~ThreadVariant();
+		virtual ~ThreadVariant();
 		ThreadVariantType type;
 		union
 		{
@@ -89,16 +83,16 @@ namespace sdl
 		~ThreadData();
 		const char *getCode();
 		const char *getName();
-		ThreadVariant* getValue(std::string name);
-		void clearValue(std::string name);
-		void setValue(std::string name, ThreadVariant *v);
+		ThreadVariant* getValue(const std::string & name);
+		void clearValue(const std::string & name);
+		void setValue(const std::string & name, ThreadVariant *v);
 	};
 
 	class Thread : public love::Object
 	{
 	private:
 		SDL_Thread *handle;
-		ThreadModuleRegistrar *reg;
+		love::thread::ThreadModule *module;
 		ThreadData *comm;
 		std::string name;
 		char *data;
@@ -107,39 +101,40 @@ namespace sdl
 		bool isThread;
 
 	public:
-		Thread(ThreadModuleRegistrar *reg, std::string name, love::Data *data);
-		Thread(ThreadModuleRegistrar *reg, std::string name);
-		~Thread();
+		Thread(love::thread::ThreadModule *module, const std::string & name, love::Data *data);
+		Thread(love::thread::ThreadModule *module, const std::string & name);
+		virtual ~Thread();
 		void start();
 		void kill();
 		void wait();
 		std::string getName();
-		ThreadVariant *receive(std::string name);
-		ThreadVariant *demand(std::string name);
-		void clear(std::string name);
-		void send(std::string name, ThreadVariant *v);
+		ThreadVariant *receive(const std::string & name);
+		ThreadVariant *demand(const std::string & name);
+		void clear(const std::string & name);
+		void send(const std::string & name, ThreadVariant *v);
 		void lock();
 		void unlock();
 	}; // Thread
 
 	typedef std::map<std::string, Thread*> threadlist_t;
 
-	class ThreadModule : public ThreadModuleRegistrar
+	class ThreadModule : public love::thread::ThreadModule
 	{
 	private:
 		threadlist_t threads;
 
 	public:
 		ThreadModule();
-		~ThreadModule();
-		Thread *newThread(std::string name, love::Data *data);
-		Thread **getThreads();
-		Thread *getThread(std::string name);
-		void unregister(std::string name);
+		virtual ~ThreadModule();
+		Thread *newThread(const std::string & name, love::Data *data);
+		void getThreads(Thread ** list);
+		Thread *getThread(const std::string & name);
+		unsigned getThreadCount() const;
+		void unregister(const std::string & name);
 		const char *getName() const;
 	}; // ThreadModule
 } // sdl
 } // thread
 } // love
 
-#endif // LOVE_THREAD_THREAD_H
+#endif // LOVE_THREAD_SDL_THREAD_H

src/modules/thread/sdl/wrap_Thread.cpp

@@ -201,7 +201,7 @@ namespace sdl
 		ThreadVariant *v;
 		if (lua_isboolean(L, 3))
 		{
-			v = new ThreadVariant((bool) lua_toboolean(L, 3));
+			v = new ThreadVariant(luax_toboolean(L, 3));
 		}
 		else if (lua_isnumber(L, 3))
 		{
@@ -260,9 +260,11 @@ namespace sdl
 
 	int w_getThreads(lua_State *L)
 	{
-		Thread **list = instance->getThreads();
+		unsigned count = instance->getThreadCount();
+		Thread **list = new Thread*[count];
+		instance->getThreads(list);
 		lua_newtable(L);
-		for (int i = 0; list[i] != 0; i++)
+		for (unsigned int i = 0; i<count; i++)
 		{
 			luax_newtype(L, "Thread", THREAD_THREAD_T, (void*) list[i]);
 			list[i]->lock();