diff --git a/platform/msvc2008/love.vcproj b/platform/msvc2008/love.vcproj index 46ec8e992..3a4a54bff 100644 --- a/platform/msvc2008/love.vcproj +++ b/platform/msvc2008/love.vcproj @@ -3232,6 +3232,10 @@ + + diff --git a/platform/msvc2008/thread/thread.vcproj b/platform/msvc2008/thread/thread.vcproj index 8866848b8..809af69b4 100644 --- a/platform/msvc2008/thread/thread.vcproj +++ b/platform/msvc2008/thread/thread.vcproj @@ -205,6 +205,10 @@ > + + diff --git a/src/modules/thread/ThreadModule.h b/src/modules/thread/ThreadModule.h new file mode 100644 index 000000000..0c09c237b --- /dev/null +++ b/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 +#include + +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 diff --git a/src/modules/thread/sdl/Thread.cpp b/src/modules/thread/sdl/Thread.cpp index e5d892ddb..22efdd98f 100644 --- a/src/modules/thread/sdl/Thread.cpp +++ b/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; diff --git a/src/modules/thread/sdl/Thread.h b/src/modules/thread/sdl/Thread.h index ddc9edd0f..69143d205 100644 --- a/src/modules/thread/sdl/Thread.h +++ b/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 @@ -30,7 +30,7 @@ #include // LOVE -#include +#include #include #include @@ -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 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 diff --git a/src/modules/thread/sdl/wrap_Thread.cpp b/src/modules/thread/sdl/wrap_Thread.cpp index 29e2c4bbf..203b981c8 100644 --- a/src/modules/thread/sdl/wrap_Thread.cpp +++ b/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; ilock();