#ifndef WTFThreadData_h
#define WTFThreadData_h
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/Noncopyable.h>
#include <wtf/StackBounds.h>
#include <wtf/text/StringHash.h>
#define WTFTHREADDATA_MULTITHREADED 1
#if WTFTHREADDATA_MULTITHREADED
#include <wtf/ThreadSpecific.h>
#include <wtf/Threading.h>
#endif
#if USE(JSC)
namespace JSC {
typedef HashMap<const char*, RefPtr<StringImpl>, PtrHash<const char*> > LiteralIdentifierTable;
class IdentifierTable {
WTF_MAKE_FAST_ALLOCATED;
public:
~IdentifierTable();
std::pair<HashSet<StringImpl*>::iterator, bool> add(StringImpl* value);
template<typename U, typename V>
std::pair<HashSet<StringImpl*>::iterator, bool> add(U value);
bool remove(StringImpl* r)
{
HashSet<StringImpl*>::iterator iter = m_table.find(r);
if (iter == m_table.end())
return false;
m_table.remove(iter);
return true;
}
LiteralIdentifierTable& literalTable() { return m_literalTable; }
private:
HashSet<StringImpl*> m_table;
LiteralIdentifierTable m_literalTable;
};
}
#endif
namespace WTF {
class AtomicStringTable;
typedef void (*AtomicStringTableDestructor)(AtomicStringTable*);
class WTFThreadData {
WTF_MAKE_NONCOPYABLE(WTFThreadData);
public:
WTFThreadData();
~WTFThreadData();
AtomicStringTable* atomicStringTable()
{
return m_atomicStringTable;
}
#if USE(JSC)
JSC::IdentifierTable* currentIdentifierTable()
{
return m_currentIdentifierTable;
}
JSC::IdentifierTable* setCurrentIdentifierTable(JSC::IdentifierTable* identifierTable)
{
JSC::IdentifierTable* oldIdentifierTable = m_currentIdentifierTable;
m_currentIdentifierTable = identifierTable;
return oldIdentifierTable;
}
void resetCurrentIdentifierTable()
{
m_currentIdentifierTable = m_defaultIdentifierTable;
}
const StackBounds& stack() const
{
return m_stackBounds;
}
#endif
private:
AtomicStringTable* m_atomicStringTable;
AtomicStringTableDestructor m_atomicStringTableDestructor;
#if USE(JSC)
JSC::IdentifierTable* m_defaultIdentifierTable;
JSC::IdentifierTable* m_currentIdentifierTable;
StackBounds m_stackBounds;
#endif
#if WTFTHREADDATA_MULTITHREADED
static JS_EXPORTDATA ThreadSpecific<WTFThreadData>* staticData;
#else
static JS_EXPORTDATA WTFThreadData* staticData;
#endif
friend WTFThreadData& wtfThreadData();
friend class AtomicStringTable;
};
inline WTFThreadData& wtfThreadData()
{
#if WTFTHREADDATA_MULTITHREADED
if (!WTFThreadData::staticData)
WTFThreadData::staticData = new ThreadSpecific<WTFThreadData>;
return **WTFThreadData::staticData;
#else
if (!WTFThreadData::staticData) {
WTFThreadData::staticData = static_cast<WTFThreadData*>(fastMalloc(sizeof(WTFThreadData)));
new (WTFThreadData::staticData) WTFThreadData;
}
return *WTFThreadData::staticData;
#endif
}
}
using WTF::WTFThreadData;
using WTF::wtfThreadData;
#endif // WTFThreadData_h