haiku.git

// ThreadLocal.cpp

#include <new>

#include <OS.h>

#include "HashMap.h"
#include "ThreadLocal.h"

// ThreadLocalFreeHandler

// constructor
ThreadLocalFreeHandler::ThreadLocalFreeHandler()
{
}

// destructor
ThreadLocalFreeHandler::~ThreadLocalFreeHandler()
{
}


// ThreadLocal

// ThreadLocalMap
struct ThreadLocal::ThreadLocalMap
	: public SynchronizedHashMap<HashKey32<thread_id>, void*> {
};

// constructor
ThreadLocal::ThreadLocal(ThreadLocalFreeHandler* freeHandler)
	: fMap(NULL),
	  fFreeHandler(freeHandler)
{
	fMap = new(std::nothrow) ThreadLocalMap;
}

// destructor
ThreadLocal::~ThreadLocal()
{
	delete fMap;
}

// Set
status_t
ThreadLocal::Set(void* data)
{
	if (!fMap)
		return B_NO_MEMORY;
	thread_id thread = find_thread(NULL);
	fMap->Lock();
	// free old data, if any
	if (fFreeHandler &&fMap->ContainsKey(thread))
		fFreeHandler->Free(fMap->Get(thread));
	// put the new data
	status_t error = fMap->Put(thread, data);
	fMap->Unlock();
	return error;
}

// Unset
void
ThreadLocal::Unset()
{
	if (!fMap)
		return;
	thread_id thread = find_thread(NULL);
	fMap->Lock();
	if (fFreeHandler) {
		if (fMap->ContainsKey(thread))
			fFreeHandler->Free(fMap->Remove(thread));
	} else
		fMap->Remove(thread);
	fMap->Unlock();
}

// Get
void*
ThreadLocal::Get() const
{
	if (!fMap)
		return NULL;
	return fMap->Get(find_thread(NULL));
}